summaryrefslogtreecommitdiffstats
path: root/dom/xslt
diff options
context:
space:
mode:
Diffstat (limited to 'dom/xslt')
-rw-r--r--dom/xslt/base/moz.build23
-rw-r--r--dom/xslt/base/txCore.h42
-rw-r--r--dom/xslt/base/txDouble.cpp194
-rw-r--r--dom/xslt/base/txErrorObserver.h36
-rw-r--r--dom/xslt/base/txExpandedName.cpp37
-rw-r--r--dom/xslt/base/txExpandedName.h50
-rw-r--r--dom/xslt/base/txExpandedNameMap.cpp94
-rw-r--r--dom/xslt/base/txExpandedNameMap.h153
-rw-r--r--dom/xslt/base/txList.cpp249
-rw-r--r--dom/xslt/base/txList.h152
-rw-r--r--dom/xslt/base/txLog.h23
-rw-r--r--dom/xslt/base/txNamespaceMap.cpp81
-rw-r--r--dom/xslt/base/txNamespaceMap.h38
-rw-r--r--dom/xslt/base/txOwningArray.h29
-rw-r--r--dom/xslt/base/txStack.h99
-rw-r--r--dom/xslt/base/txStringUtils.h28
-rw-r--r--dom/xslt/base/txURIUtils.cpp87
-rw-r--r--dom/xslt/base/txURIUtils.h40
-rw-r--r--dom/xslt/crashtests/1089049.html3
-rw-r--r--dom/xslt/crashtests/111994.xml5
-rw-r--r--dom/xslt/crashtests/111994.xsl13
-rw-r--r--dom/xslt/crashtests/1205163.xml6
-rw-r--r--dom/xslt/crashtests/1205163.xsl11
-rw-r--r--dom/xslt/crashtests/1243337.xml3
-rw-r--r--dom/xslt/crashtests/1243337.xsl6
-rw-r--r--dom/xslt/crashtests/1330492.html23
-rw-r--r--dom/xslt/crashtests/1336828.html22
-rw-r--r--dom/xslt/crashtests/1336830.html27
-rw-r--r--dom/xslt/crashtests/1336832.html28
-rw-r--r--dom/xslt/crashtests/1338277.html21
-rw-r--r--dom/xslt/crashtests/1361892.html23
-rw-r--r--dom/xslt/crashtests/1430818.sjs49
-rw-r--r--dom/xslt/crashtests/1430818.xml4
-rw-r--r--dom/xslt/crashtests/1527277.html14
-rw-r--r--dom/xslt/crashtests/1589930.xml10
-rw-r--r--dom/xslt/crashtests/182460-select.xml3
-rw-r--r--dom/xslt/crashtests/182460-selects.xsl5
-rw-r--r--dom/xslt/crashtests/182460-table.xhtml9
-rw-r--r--dom/xslt/crashtests/226425.xml4
-rw-r--r--dom/xslt/crashtests/226425.xsl10
-rw-r--r--dom/xslt/crashtests/406106-1.html18
-rw-r--r--dom/xslt/crashtests/483444.xml19
-rw-r--r--dom/xslt/crashtests/485217.xml8
-rw-r--r--dom/xslt/crashtests/485217.xsl18
-rw-r--r--dom/xslt/crashtests/485286.xml12
-rw-r--r--dom/xslt/crashtests/527558_1.xml17
-rw-r--r--dom/xslt/crashtests/528300.xml22
-rw-r--r--dom/xslt/crashtests/528488.xml19
-rw-r--r--dom/xslt/crashtests/528963.xml22
-rw-r--r--dom/xslt/crashtests/545927.html28
-rw-r--r--dom/xslt/crashtests/601543.html4
-rw-r--r--dom/xslt/crashtests/602115.html22
-rw-r--r--dom/xslt/crashtests/603844.html32
-rw-r--r--dom/xslt/crashtests/667315.xml11
-rw-r--r--dom/xslt/crashtests/91332.xml10
-rw-r--r--dom/xslt/crashtests/91332.xsl21
-rw-r--r--dom/xslt/crashtests/949990.html15
-rw-r--r--dom/xslt/crashtests/crashtests.list30
-rw-r--r--dom/xslt/moz.build23
-rw-r--r--dom/xslt/nsIDocumentTransformer.h74
-rw-r--r--dom/xslt/tests/XSLTMark/XSLTMark-static.js46
-rw-r--r--dom/xslt/tests/XSLTMark/XSLTMark-test.js41
-rw-r--r--dom/xslt/tests/XSLTMark/XSLTMark-view.js171
-rw-r--r--dom/xslt/tests/XSLTMark/XSLTMark.css8
-rw-r--r--dom/xslt/tests/XSLTMark/XSLTMark.xhtml53
-rw-r--r--dom/xslt/tests/browser/browser.ini7
-rw-r--r--dom/xslt/tests/browser/browser_bug1309630.js74
-rw-r--r--dom/xslt/tests/browser/bug1309630.sjs54
-rw-r--r--dom/xslt/tests/browser/file_bug1309630.html19
-rw-r--r--dom/xslt/tests/mochitest/bug1729517_2.sjs3
-rw-r--r--dom/xslt/tests/mochitest/file_bug1135764.xml3
-rw-r--r--dom/xslt/tests/mochitest/file_bug1135764.xsl19
-rw-r--r--dom/xslt/tests/mochitest/file_bug1729517.js3
-rw-r--r--dom/xslt/tests/mochitest/file_bug1729517.xml31
-rw-r--r--dom/xslt/tests/mochitest/file_bug1729517_2.xml38
-rw-r--r--dom/xslt/tests/mochitest/file_bug1729517_2.xml^headers^2
-rw-r--r--dom/xslt/tests/mochitest/file_metaRefresh.xml16
-rw-r--r--dom/xslt/tests/mochitest/mochitest.ini33
-rw-r--r--dom/xslt/tests/mochitest/test_bug1072116.html37
-rw-r--r--dom/xslt/tests/mochitest/test_bug1135764.html58
-rw-r--r--dom/xslt/tests/mochitest/test_bug1436040.html54
-rw-r--r--dom/xslt/tests/mochitest/test_bug1527308.html38
-rw-r--r--dom/xslt/tests/mochitest/test_bug1729517.html48
-rw-r--r--dom/xslt/tests/mochitest/test_bug319374.html101
-rw-r--r--dom/xslt/tests/mochitest/test_bug427060.html49
-rw-r--r--dom/xslt/tests/mochitest/test_bug440974.html46
-rw-r--r--dom/xslt/tests/mochitest/test_bug453441.html57
-rw-r--r--dom/xslt/tests/mochitest/test_bug468208.html35
-rw-r--r--dom/xslt/tests/mochitest/test_bug511487.html59
-rw-r--r--dom/xslt/tests/mochitest/test_bug551412.html48
-rw-r--r--dom/xslt/tests/mochitest/test_bug551654.html49
-rw-r--r--dom/xslt/tests/mochitest/test_bug566629.html70
-rw-r--r--dom/xslt/tests/mochitest/test_bug566629.xhtml73
-rw-r--r--dom/xslt/tests/mochitest/test_bug603159.html54
-rw-r--r--dom/xslt/tests/mochitest/test_bug616774.html28
-rw-r--r--dom/xslt/tests/mochitest/test_bug667315.html46
-rw-r--r--dom/xslt/tests/mochitest/test_exslt.html249
-rw-r--r--dom/xslt/tests/mochitest/test_metaRefresh.html48
-rw-r--r--dom/xslt/tests/mochitest/test_parameter.html156
-rw-r--r--dom/xslt/tests/mochitest/test_sorting_invalid_lang.html82
-rw-r--r--dom/xslt/xml/moz.build19
-rw-r--r--dom/xslt/xml/txXMLParser.cpp59
-rw-r--r--dom/xslt/xml/txXMLParser.h27
-rw-r--r--dom/xslt/xml/txXMLUtils.cpp164
-rw-r--r--dom/xslt/xml/txXMLUtils.h75
-rw-r--r--dom/xslt/xpath/XPathEvaluator.cpp188
-rw-r--r--dom/xslt/xpath/XPathEvaluator.h66
-rw-r--r--dom/xslt/xpath/XPathExpression.cpp210
-rw-r--r--dom/xslt/xpath/XPathExpression.h68
-rw-r--r--dom/xslt/xpath/XPathResult.cpp264
-rw-r--r--dom/xslt/xpath/XPathResult.h156
-rw-r--r--dom/xslt/xpath/moz.build58
-rw-r--r--dom/xslt/xpath/txBooleanExpr.cpp78
-rw-r--r--dom/xslt/xpath/txBooleanResult.cpp48
-rw-r--r--dom/xslt/xpath/txCoreFunctionCall.cpp665
-rw-r--r--dom/xslt/xpath/txErrorExpr.cpp35
-rw-r--r--dom/xslt/xpath/txExpr.cpp26
-rw-r--r--dom/xslt/xpath/txExpr.h847
-rw-r--r--dom/xslt/xpath/txExprLexer.cpp333
-rw-r--r--dom/xslt/xpath/txExprLexer.h200
-rw-r--r--dom/xslt/xpath/txExprParser.cpp855
-rw-r--r--dom/xslt/xpath/txExprParser.h95
-rw-r--r--dom/xslt/xpath/txExprResult.h118
-rw-r--r--dom/xslt/xpath/txFilterExpr.cpp88
-rw-r--r--dom/xslt/xpath/txForwardContext.cpp50
-rw-r--r--dom/xslt/xpath/txForwardContext.h28
-rw-r--r--dom/xslt/xpath/txFunctionCall.cpp110
-rw-r--r--dom/xslt/xpath/txIXPathContext.h132
-rw-r--r--dom/xslt/xpath/txLiteralExpr.cpp74
-rw-r--r--dom/xslt/xpath/txLocationStep.cpp308
-rw-r--r--dom/xslt/xpath/txMozillaXPathTreeWalker.cpp674
-rw-r--r--dom/xslt/xpath/txNameTest.cpp92
-rw-r--r--dom/xslt/xpath/txNamedAttributeStep.cpp53
-rw-r--r--dom/xslt/xpath/txNodeSet.cpp567
-rw-r--r--dom/xslt/xpath/txNodeSet.h199
-rw-r--r--dom/xslt/xpath/txNodeSetContext.cpp51
-rw-r--r--dom/xslt/xpath/txNodeSetContext.h36
-rw-r--r--dom/xslt/xpath/txNodeTypeTest.cpp91
-rw-r--r--dom/xslt/xpath/txNumberExpr.cpp108
-rw-r--r--dom/xslt/xpath/txNumberResult.cpp48
-rw-r--r--dom/xslt/xpath/txPathExpr.cpp229
-rw-r--r--dom/xslt/xpath/txPredicateList.cpp78
-rw-r--r--dom/xslt/xpath/txPredicatedNodeTest.cpp50
-rw-r--r--dom/xslt/xpath/txRelationalExpr.cpp184
-rw-r--r--dom/xslt/xpath/txResultRecycler.cpp171
-rw-r--r--dom/xslt/xpath/txResultRecycler.h76
-rw-r--r--dom/xslt/xpath/txRootExpr.cpp35
-rw-r--r--dom/xslt/xpath/txSingleNodeContext.h64
-rw-r--r--dom/xslt/xpath/txStringResult.cpp43
-rw-r--r--dom/xslt/xpath/txUnaryExpr.cpp49
-rw-r--r--dom/xslt/xpath/txUnionExpr.cpp85
-rw-r--r--dom/xslt/xpath/txUnionNodeTest.cpp59
-rw-r--r--dom/xslt/xpath/txVariableRefExpr.cpp62
-rw-r--r--dom/xslt/xpath/txXPathNode.h91
-rw-r--r--dom/xslt/xpath/txXPathOptimizer.cpp246
-rw-r--r--dom/xslt/xpath/txXPathOptimizer.h30
-rw-r--r--dom/xslt/xpath/txXPathTreeWalker.h201
-rw-r--r--dom/xslt/xslt/moz.build66
-rw-r--r--dom/xslt/xslt/txBufferingHandler.cpp385
-rw-r--r--dom/xslt/xslt/txBufferingHandler.h45
-rw-r--r--dom/xslt/xslt/txCurrentFunctionCall.cpp50
-rw-r--r--dom/xslt/xslt/txDocumentFunctionCall.cpp150
-rw-r--r--dom/xslt/xslt/txEXSLTFunctions.cpp818
-rw-r--r--dom/xslt/xslt/txEXSLTRegExFunctions.sys.mjs32
-rw-r--r--dom/xslt/xslt/txExecutionState.cpp460
-rw-r--r--dom/xslt/xslt/txExecutionState.h166
-rw-r--r--dom/xslt/xslt/txFormatNumberFunctionCall.cpp406
-rw-r--r--dom/xslt/xslt/txGenerateIdFunctionCall.cpp99
-rw-r--r--dom/xslt/xslt/txIEXSLTFunctions.idl20
-rw-r--r--dom/xslt/xslt/txInstructions.cpp764
-rw-r--r--dom/xslt/xslt/txInstructions.h362
-rw-r--r--dom/xslt/xslt/txKey.h186
-rw-r--r--dom/xslt/xslt/txKeyFunctionCall.cpp345
-rw-r--r--dom/xslt/xslt/txMozillaStylesheetCompiler.cpp622
-rw-r--r--dom/xslt/xslt/txMozillaTextOutput.cpp250
-rw-r--r--dom/xslt/xslt/txMozillaTextOutput.h47
-rw-r--r--dom/xslt/xslt/txMozillaXMLOutput.cpp948
-rw-r--r--dom/xslt/xslt/txMozillaXMLOutput.h130
-rw-r--r--dom/xslt/xslt/txMozillaXSLTProcessor.cpp1227
-rw-r--r--dom/xslt/xslt/txMozillaXSLTProcessor.h170
-rw-r--r--dom/xslt/xslt/txNodeSorter.cpp240
-rw-r--r--dom/xslt/xslt/txNodeSorter.h55
-rw-r--r--dom/xslt/xslt/txOutputFormat.cpp101
-rw-r--r--dom/xslt/xslt/txOutputFormat.h64
-rw-r--r--dom/xslt/xslt/txPatternOptimizer.cpp65
-rw-r--r--dom/xslt/xslt/txPatternOptimizer.h30
-rw-r--r--dom/xslt/xslt/txPatternParser.cpp260
-rw-r--r--dom/xslt/xslt/txPatternParser.h35
-rw-r--r--dom/xslt/xslt/txRtfHandler.cpp54
-rw-r--r--dom/xslt/xslt/txRtfHandler.h42
-rw-r--r--dom/xslt/xslt/txStylesheet.cpp550
-rw-r--r--dom/xslt/xslt/txStylesheet.h185
-rw-r--r--dom/xslt/xslt/txStylesheetCompileHandlers.cpp2352
-rw-r--r--dom/xslt/xslt/txStylesheetCompileHandlers.h54
-rw-r--r--dom/xslt/xslt/txStylesheetCompiler.cpp839
-rw-r--r--dom/xslt/xslt/txStylesheetCompiler.h234
-rw-r--r--dom/xslt/xslt/txTextHandler.cpp60
-rw-r--r--dom/xslt/xslt/txTextHandler.h25
-rw-r--r--dom/xslt/xslt/txToplevelItems.cpp45
-rw-r--r--dom/xslt/xslt/txToplevelItems.h118
-rw-r--r--dom/xslt/xslt/txUnknownHandler.cpp177
-rw-r--r--dom/xslt/xslt/txUnknownHandler.h37
-rw-r--r--dom/xslt/xslt/txVariableMap.h88
-rw-r--r--dom/xslt/xslt/txXMLEventHandler.h184
-rw-r--r--dom/xslt/xslt/txXPathResultComparator.cpp173
-rw-r--r--dom/xslt/xslt/txXPathResultComparator.h92
-rw-r--r--dom/xslt/xslt/txXSLTEnvironmentFunctionCall.cpp124
-rw-r--r--dom/xslt/xslt/txXSLTFunctions.h149
-rw-r--r--dom/xslt/xslt/txXSLTMsgsURL.h11
-rw-r--r--dom/xslt/xslt/txXSLTNumber.cpp741
-rw-r--r--dom/xslt/xslt/txXSLTNumber.h67
-rw-r--r--dom/xslt/xslt/txXSLTNumberCounters.cpp199
-rw-r--r--dom/xslt/xslt/txXSLTPatterns.cpp530
-rw-r--r--dom/xslt/xslt/txXSLTPatterns.h200
-rw-r--r--dom/xslt/xslt/txXSLTProcessor.cpp50
-rw-r--r--dom/xslt/xslt/txXSLTProcessor.h26
216 files changed, 29405 insertions, 0 deletions
diff --git a/dom/xslt/base/moz.build b/dom/xslt/base/moz.build
new file mode 100644
index 0000000000..1b22391983
--- /dev/null
+++ b/dom/xslt/base/moz.build
@@ -0,0 +1,23 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+UNIFIED_SOURCES += [
+ "txDouble.cpp",
+ "txExpandedName.cpp",
+ "txExpandedNameMap.cpp",
+ "txList.cpp",
+ "txNamespaceMap.cpp",
+ "txURIUtils.cpp",
+]
+
+LOCAL_INCLUDES += [
+ "..",
+ "../xml",
+ "../xpath",
+ "../xslt",
+]
+
+FINAL_LIBRARY = "xul"
diff --git a/dom/xslt/base/txCore.h b/dom/xslt/base/txCore.h
new file mode 100644
index 0000000000..6e462a5a31
--- /dev/null
+++ b/dom/xslt/base/txCore.h
@@ -0,0 +1,42 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef __txCore_h__
+#define __txCore_h__
+
+#include "nscore.h"
+#include "nsDebug.h"
+#include "nsISupportsImpl.h"
+#include "nsStringFwd.h"
+
+class txObject {
+ public:
+ MOZ_COUNTED_DEFAULT_CTOR(txObject)
+
+ /**
+ * Deletes this txObject
+ */
+ MOZ_COUNTED_DTOR_VIRTUAL(txObject)
+};
+
+/**
+ * Utility class for doubles
+ */
+class txDouble {
+ public:
+ /**
+ * Converts the value of the given double to a string, and appends
+ * the result to the destination string.
+ */
+ static void toString(double aValue, nsAString& aDest);
+
+ /**
+ * Converts the given String to a double, if the string value does not
+ * represent a double, NaN will be returned.
+ */
+ static double toDouble(const nsAString& aStr);
+};
+
+#endif
diff --git a/dom/xslt/base/txDouble.cpp b/dom/xslt/base/txDouble.cpp
new file mode 100644
index 0000000000..ad7fa690be
--- /dev/null
+++ b/dom/xslt/base/txDouble.cpp
@@ -0,0 +1,194 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/FloatingPoint.h"
+
+#include "nsString.h"
+#include "txCore.h"
+#include "txXMLUtils.h"
+#include <math.h>
+#include <stdlib.h>
+#include <algorithm>
+#ifdef WIN32
+# include <float.h>
+#endif
+#include "prdtoa.h"
+
+/*
+ * Utility class for doubles
+ */
+
+/*
+ * Converts the given String to a double, if the String value does not
+ * represent a double, NaN will be returned
+ */
+class txStringToDouble {
+ public:
+ txStringToDouble() : mState(eWhitestart), mSign(ePositive) {}
+
+ void Parse(const nsAString& aSource) {
+ if (mState == eIllegal) {
+ return;
+ }
+ uint32_t i = 0;
+ char16_t c;
+ auto len = aSource.Length();
+ for (; i < len; ++i) {
+ c = aSource[i];
+ switch (mState) {
+ case eWhitestart:
+ if (c == '-') {
+ mState = eDecimal;
+ mSign = eNegative;
+ } else if (c >= '0' && c <= '9') {
+ mState = eDecimal;
+ mBuffer.Append((char)c);
+ } else if (c == '.') {
+ mState = eMantissa;
+ mBuffer.Append((char)c);
+ } else if (!XMLUtils::isWhitespace(c)) {
+ mState = eIllegal;
+ return;
+ }
+ break;
+ case eDecimal:
+ if (c >= '0' && c <= '9') {
+ mBuffer.Append((char)c);
+ } else if (c == '.') {
+ mState = eMantissa;
+ mBuffer.Append((char)c);
+ } else if (XMLUtils::isWhitespace(c)) {
+ mState = eWhiteend;
+ } else {
+ mState = eIllegal;
+ return;
+ }
+ break;
+ case eMantissa:
+ if (c >= '0' && c <= '9') {
+ mBuffer.Append((char)c);
+ } else if (XMLUtils::isWhitespace(c)) {
+ mState = eWhiteend;
+ } else {
+ mState = eIllegal;
+ return;
+ }
+ break;
+ case eWhiteend:
+ if (!XMLUtils::isWhitespace(c)) {
+ mState = eIllegal;
+ return;
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ }
+
+ double getDouble() {
+ if (mState == eIllegal || mBuffer.IsEmpty() ||
+ (mBuffer.Length() == 1 && mBuffer[0] == '.')) {
+ return mozilla::UnspecifiedNaN<double>();
+ }
+ return static_cast<double>(mSign) * PR_strtod(mBuffer.get(), nullptr);
+ }
+
+ private:
+ nsAutoCString mBuffer;
+ enum { eWhitestart, eDecimal, eMantissa, eWhiteend, eIllegal } mState;
+ enum { eNegative = -1, ePositive = 1 } mSign;
+};
+
+double txDouble::toDouble(const nsAString& aSrc) {
+ txStringToDouble sink;
+ sink.Parse(aSrc);
+ return sink.getDouble();
+}
+
+/*
+ * Converts the value of the given double to a String, and places
+ * The result into the destination String.
+ * @return the given dest string
+ */
+void txDouble::toString(double aValue, nsAString& aDest) {
+ // check for special cases
+
+ if (std::isnan(aValue)) {
+ aDest.AppendLiteral("NaN");
+ return;
+ }
+ if (std::isinf(aValue)) {
+ if (aValue < 0) aDest.Append(char16_t('-'));
+ aDest.AppendLiteral("Infinity");
+ return;
+ }
+
+ // Mantissa length is 17, so this is plenty
+ const int buflen = 20;
+ char buf[buflen];
+
+ int intDigits, sign;
+ char* endp;
+ PR_dtoa(aValue, 0, 0, &intDigits, &sign, &endp, buf, buflen - 1);
+
+ // compute length
+ int32_t length = endp - buf;
+ if (length > intDigits) {
+ // decimal point needed
+ ++length;
+ if (intDigits < 1) {
+ // leading zeros, -intDigits + 1
+ length += 1 - intDigits;
+ }
+ } else {
+ // trailing zeros, total length given by intDigits
+ length = intDigits;
+ }
+ if (aValue < 0) ++length;
+ // grow the string
+ uint32_t oldlength = aDest.Length();
+ if (!aDest.SetLength(oldlength + length, mozilla::fallible))
+ return; // out of memory
+ auto dest = aDest.BeginWriting();
+ std::advance(dest, oldlength);
+ if (aValue < 0) {
+ *dest = '-';
+ ++dest;
+ }
+ int i;
+ // leading zeros
+ if (intDigits < 1) {
+ *dest = '0';
+ ++dest;
+ *dest = '.';
+ ++dest;
+ for (i = 0; i > intDigits; --i) {
+ *dest = '0';
+ ++dest;
+ }
+ }
+ // mantissa
+ int firstlen = std::min<size_t>(intDigits, endp - buf);
+ for (i = 0; i < firstlen; i++) {
+ *dest = buf[i];
+ ++dest;
+ }
+ if (i < endp - buf) {
+ if (i > 0) {
+ *dest = '.';
+ ++dest;
+ }
+ for (; i < endp - buf; i++) {
+ *dest = buf[i];
+ ++dest;
+ }
+ }
+ // trailing zeros
+ for (; i < intDigits; i++) {
+ *dest = '0';
+ ++dest;
+ }
+}
diff --git a/dom/xslt/base/txErrorObserver.h b/dom/xslt/base/txErrorObserver.h
new file mode 100644
index 0000000000..30b541f2a9
--- /dev/null
+++ b/dom/xslt/base/txErrorObserver.h
@@ -0,0 +1,36 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef MITRE_ERROROBSERVER_H
+#define MITRE_ERROROBSERVER_H
+
+#include "txCore.h"
+
+/**
+ * A simple interface for observing errors
+ **/
+class ErrorObserver {
+ public:
+ /**
+ * Default Destructor for ErrorObserver
+ **/
+ virtual ~ErrorObserver(){};
+
+ /**
+ * Notifies this Error observer of a new error aRes
+ **/
+ virtual void receiveError(const nsAString& errorMessage, nsresult aRes) = 0;
+
+ /**
+ * Notifies this Error observer of a new error, with default
+ * error code NS_ERROR_FAILURE
+ **/
+ void receiveError(const nsAString& errorMessage) {
+ receiveError(errorMessage, NS_ERROR_FAILURE);
+ }
+
+}; //-- ErrorObserver
+
+#endif
diff --git a/dom/xslt/base/txExpandedName.cpp b/dom/xslt/base/txExpandedName.cpp
new file mode 100644
index 0000000000..af11476056
--- /dev/null
+++ b/dom/xslt/base/txExpandedName.cpp
@@ -0,0 +1,37 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txExpandedName.h"
+#include "nsString.h"
+#include "nsReadableUtils.h"
+#include "txStringUtils.h"
+#include "txNamespaceMap.h"
+#include "txXMLUtils.h"
+
+nsresult txExpandedName::init(const nsAString& aQName,
+ txNamespaceMap* aResolver, bool aUseDefault) {
+ const nsString& qName = PromiseFlatString(aQName);
+ const char16_t* colon;
+ bool valid = XMLUtils::isValidQName(qName, &colon);
+ if (!valid) {
+ return NS_ERROR_FAILURE;
+ }
+
+ if (colon) {
+ RefPtr<nsAtom> prefix = NS_Atomize(Substring(qName.get(), colon));
+ int32_t namespaceID = aResolver->lookupNamespace(prefix);
+ if (namespaceID == kNameSpaceID_Unknown) return NS_ERROR_FAILURE;
+ mNamespaceID = namespaceID;
+
+ const char16_t* end;
+ qName.EndReading(end);
+ mLocalName = NS_Atomize(Substring(colon + 1, end));
+ } else {
+ mNamespaceID =
+ aUseDefault ? aResolver->lookupNamespace(nullptr) : kNameSpaceID_None;
+ mLocalName = NS_Atomize(aQName);
+ }
+ return NS_OK;
+}
diff --git a/dom/xslt/base/txExpandedName.h b/dom/xslt/base/txExpandedName.h
new file mode 100644
index 0000000000..76d82a8eee
--- /dev/null
+++ b/dom/xslt/base/txExpandedName.h
@@ -0,0 +1,50 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef TRANSFRMX_EXPANDEDNAME_H
+#define TRANSFRMX_EXPANDEDNAME_H
+
+#include "nsCOMPtr.h"
+#include "nsAtom.h"
+#include "mozilla/dom/NameSpaceConstants.h"
+
+class txNamespaceMap;
+
+class txExpandedName {
+ public:
+ txExpandedName() : mNamespaceID(kNameSpaceID_None) {}
+
+ txExpandedName(int32_t aNsID, nsAtom* aLocalName)
+ : mNamespaceID(aNsID), mLocalName(aLocalName) {}
+
+ txExpandedName(const txExpandedName& aOther) = default;
+
+ nsresult init(const nsAString& aQName, txNamespaceMap* aResolver,
+ bool aUseDefault);
+
+ void reset() {
+ mNamespaceID = kNameSpaceID_None;
+ mLocalName = nullptr;
+ }
+
+ bool isNull() { return mNamespaceID == kNameSpaceID_None && !mLocalName; }
+
+ txExpandedName& operator=(const txExpandedName& rhs) = default;
+
+ bool operator==(const txExpandedName& rhs) const {
+ return ((mLocalName == rhs.mLocalName) &&
+ (mNamespaceID == rhs.mNamespaceID));
+ }
+
+ bool operator!=(const txExpandedName& rhs) const {
+ return ((mLocalName != rhs.mLocalName) ||
+ (mNamespaceID != rhs.mNamespaceID));
+ }
+
+ int32_t mNamespaceID;
+ RefPtr<nsAtom> mLocalName;
+};
+
+#endif
diff --git a/dom/xslt/base/txExpandedNameMap.cpp b/dom/xslt/base/txExpandedNameMap.cpp
new file mode 100644
index 0000000000..996799abf0
--- /dev/null
+++ b/dom/xslt/base/txExpandedNameMap.cpp
@@ -0,0 +1,94 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txExpandedNameMap.h"
+#include "txCore.h"
+
+class txMapItemComparator {
+ public:
+ bool Equals(const txExpandedNameMap_base::MapItem& aItem,
+ const txExpandedName& aKey) const {
+ return aItem.mNamespaceID == aKey.mNamespaceID &&
+ aItem.mLocalName == aKey.mLocalName;
+ }
+};
+
+/**
+ * Adds an item, if an item with this key already exists an error is
+ * returned
+ * @param aKey key for item to add
+ * @param aValue value of item to add
+ * @return errorcode
+ */
+nsresult txExpandedNameMap_base::addItem(const txExpandedName& aKey,
+ void* aValue) {
+ size_t pos = mItems.IndexOf(aKey, 0, txMapItemComparator());
+ if (pos != mItems.NoIndex) {
+ return NS_ERROR_XSLT_ALREADY_SET;
+ }
+
+ MapItem* item = mItems.AppendElement();
+ item->mNamespaceID = aKey.mNamespaceID;
+ item->mLocalName = aKey.mLocalName;
+ item->mValue = aValue;
+
+ return NS_OK;
+}
+
+/**
+ * Sets an item, if an item with this key already exists it is overwritten
+ * with the new value
+ * @param aKey key for item to set
+ * @param aValue value of item to set
+ * @return errorcode
+ */
+nsresult txExpandedNameMap_base::setItem(const txExpandedName& aKey,
+ void* aValue, void** aOldValue) {
+ *aOldValue = nullptr;
+ size_t pos = mItems.IndexOf(aKey, 0, txMapItemComparator());
+ if (pos != mItems.NoIndex) {
+ *aOldValue = mItems[pos].mValue;
+ mItems[pos].mValue = aValue;
+ return NS_OK;
+ }
+
+ MapItem* item = mItems.AppendElement();
+ item->mNamespaceID = aKey.mNamespaceID;
+ item->mLocalName = aKey.mLocalName;
+ item->mValue = aValue;
+
+ return NS_OK;
+}
+
+/**
+ * Gets an item
+ * @param aKey key for item to get
+ * @return item with specified key, or null if no such item exists
+ */
+void* txExpandedNameMap_base::getItem(const txExpandedName& aKey) const {
+ size_t pos = mItems.IndexOf(aKey, 0, txMapItemComparator());
+ if (pos != mItems.NoIndex) {
+ return mItems[pos].mValue;
+ }
+
+ return nullptr;
+}
+
+/**
+ * Removes an item, deleting it if the map owns the values
+ * @param aKey key for item to remove
+ * @return item with specified key, or null if it has been deleted
+ * or no such item exists
+ */
+void* txExpandedNameMap_base::removeItem(const txExpandedName& aKey) {
+ void* value = nullptr;
+ size_t pos = mItems.IndexOf(aKey, 0, txMapItemComparator());
+ if (pos != mItems.NoIndex) {
+ value = mItems[pos].mValue;
+ mItems.RemoveElementAt(pos);
+ }
+
+ return value;
+}
diff --git a/dom/xslt/base/txExpandedNameMap.h b/dom/xslt/base/txExpandedNameMap.h
new file mode 100644
index 0000000000..6e308a65f8
--- /dev/null
+++ b/dom/xslt/base/txExpandedNameMap.h
@@ -0,0 +1,153 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef TRANSFRMX_EXPANDEDNAMEMAP_H
+#define TRANSFRMX_EXPANDEDNAMEMAP_H
+
+#include "mozilla/UniquePtr.h"
+#include "mozilla/UniquePtrExtensions.h"
+#include "nsError.h"
+#include "txExpandedName.h"
+#include "nsTArray.h"
+
+class txExpandedNameMap_base {
+ protected:
+ /**
+ * Adds an item, if an item with this key already exists an error is
+ * returned
+ * @param aKey key for item to add
+ * @param aValue value of item to add
+ * @return errorcode
+ */
+ nsresult addItem(const txExpandedName& aKey, void* aValue);
+
+ /**
+ * Sets an item, if an item with this key already exists it is overwritten
+ * with the new value
+ * @param aKey key for item to set
+ * @param aValue value of item to set
+ * @return errorcode
+ */
+ nsresult setItem(const txExpandedName& aKey, void* aValue, void** aOldValue);
+
+ /**
+ * Gets an item
+ * @param aKey key for item to get
+ * @return item with specified key, or null if no such item exists
+ */
+ void* getItem(const txExpandedName& aKey) const;
+
+ /**
+ * Removes an item, deleting it if the map owns the values
+ * @param aKey key for item to remove
+ * @return item with specified key, or null if it has been deleted
+ * or no such item exists
+ */
+ void* removeItem(const txExpandedName& aKey);
+
+ /**
+ * Clears the items
+ */
+ void clearItems() { mItems.Clear(); }
+
+ class iterator_base {
+ public:
+ explicit iterator_base(txExpandedNameMap_base& aMap)
+ : mMap(aMap), mCurrentPos(uint32_t(-1)) {}
+
+ bool next() { return ++mCurrentPos < mMap.mItems.Length(); }
+
+ const txExpandedName key() {
+ NS_ASSERTION(mCurrentPos < mMap.mItems.Length(),
+ "invalid position in txExpandedNameMap::iterator");
+ return txExpandedName(mMap.mItems[mCurrentPos].mNamespaceID,
+ mMap.mItems[mCurrentPos].mLocalName);
+ }
+
+ protected:
+ void* itemValue() {
+ NS_ASSERTION(mCurrentPos < mMap.mItems.Length(),
+ "invalid position in txExpandedNameMap::iterator");
+ return mMap.mItems[mCurrentPos].mValue;
+ }
+
+ private:
+ txExpandedNameMap_base& mMap;
+ uint32_t mCurrentPos;
+ };
+
+ friend class iterator_base;
+
+ friend class txMapItemComparator;
+ struct MapItem {
+ int32_t mNamespaceID;
+ RefPtr<nsAtom> mLocalName;
+ void* mValue;
+ };
+
+ nsTArray<MapItem> mItems;
+};
+
+template <class E>
+class txExpandedNameMap : public txExpandedNameMap_base {
+ public:
+ nsresult add(const txExpandedName& aKey, E* aValue) {
+ return addItem(aKey, (void*)aValue);
+ }
+
+ nsresult set(const txExpandedName& aKey, E* aValue) {
+ void* oldValue;
+ return setItem(aKey, (void*)aValue, &oldValue);
+ }
+
+ E* get(const txExpandedName& aKey) const { return (E*)getItem(aKey); }
+
+ E* remove(const txExpandedName& aKey) { return (E*)removeItem(aKey); }
+
+ void clear() { clearItems(); }
+
+ class iterator : public iterator_base {
+ public:
+ explicit iterator(txExpandedNameMap& aMap) : iterator_base(aMap) {}
+
+ E* value() { return (E*)itemValue(); }
+ };
+};
+
+template <class E>
+class txOwningExpandedNameMap : public txExpandedNameMap_base {
+ public:
+ ~txOwningExpandedNameMap() { clear(); }
+
+ nsresult add(const txExpandedName& aKey, E* aValue) {
+ return addItem(aKey, (void*)aValue);
+ }
+
+ nsresult set(const txExpandedName& aKey, E* aValue) {
+ mozilla::UniquePtr<E> oldValue;
+ return setItem(aKey, (void*)aValue, getter_Transfers(oldValue));
+ }
+
+ E* get(const txExpandedName& aKey) const { return (E*)getItem(aKey); }
+
+ void remove(const txExpandedName& aKey) { delete (E*)removeItem(aKey); }
+
+ void clear() {
+ uint32_t i, len = mItems.Length();
+ for (i = 0; i < len; ++i) {
+ delete (E*)mItems[i].mValue;
+ }
+ clearItems();
+ }
+
+ class iterator : public iterator_base {
+ public:
+ explicit iterator(txOwningExpandedNameMap& aMap) : iterator_base(aMap) {}
+
+ E* value() { return (E*)itemValue(); }
+ };
+};
+
+#endif // TRANSFRMX_EXPANDEDNAMEMAP_H
diff --git a/dom/xslt/base/txList.cpp b/dom/xslt/base/txList.cpp
new file mode 100644
index 0000000000..a361490784
--- /dev/null
+++ b/dom/xslt/base/txList.cpp
@@ -0,0 +1,249 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txList.h"
+
+//----------------------------/
+//- Implementation of txList -/
+//----------------------------/
+
+/**
+ * Default constructor for a txList;
+ **/
+
+txList::txList() {
+ firstItem = 0;
+ lastItem = 0;
+ itemCount = 0;
+} //-- txList;
+
+/**
+ * txList destructor, cleans up ListItems, but will not delete the Object
+ * references
+ */
+txList::~txList() { clear(); } //-- ~txList
+
+void txList::add(void* objPtr) { insertBefore(objPtr, nullptr); } //-- add
+
+/**
+ * Returns the number of items in this txList
+ **/
+int32_t List::getLength() { return itemCount; } //-- getLength
+
+/**
+ * Inserts the given Object pointer as the item just after refItem.
+ * If refItem is a null pointer the Object will be inserted at the
+ * beginning of the txList (ie, insert after nothing).
+ * This method assumes refItem is a member of this list, and since this
+ * is a private method, I feel that's a valid assumption
+ **/
+void txList::insertAfter(void* objPtr, ListItem* refItem) {
+ insertBefore(objPtr, refItem ? refItem->nextItem : firstItem);
+} //-- insertAfter
+
+/**
+ * Inserts the given Object pointer as the item just before refItem.
+ * If refItem is a null pointer the Object will be inserted at the
+ * end of the txList (ie, insert before nothing).
+ * This method assumes refItem is a member of this list, and since this
+ * is a private method, I feel that's a valid assumption
+ **/
+void txList::insertBefore(void* objPtr, ListItem* refItem) {
+ ListItem* item = new ListItem;
+ item->objPtr = objPtr;
+ item->nextItem = 0;
+ item->prevItem = 0;
+
+ //-- if refItem == null insert at end
+ if (!refItem) {
+ //-- add to back of list
+ if (lastItem) {
+ lastItem->nextItem = item;
+ item->prevItem = lastItem;
+ }
+ lastItem = item;
+ if (!firstItem) firstItem = item;
+ } else {
+ //-- insert before given item
+ item->nextItem = refItem;
+ item->prevItem = refItem->prevItem;
+ refItem->prevItem = item;
+
+ if (item->prevItem)
+ item->prevItem->nextItem = item;
+ else
+ firstItem = item;
+ }
+
+ // increase the item count
+ ++itemCount;
+} //-- insertBefore
+
+txList::ListItem* txList::remove(ListItem* item) {
+ if (!item) return item;
+
+ //-- adjust the previous item's next pointer
+ if (item->prevItem) {
+ item->prevItem->nextItem = item->nextItem;
+ }
+ //-- adjust the next item's previous pointer
+ if (item->nextItem) {
+ item->nextItem->prevItem = item->prevItem;
+ }
+
+ //-- adjust first and last items
+ if (item == firstItem) firstItem = item->nextItem;
+ if (item == lastItem) lastItem = item->prevItem;
+
+ //-- decrease Item count
+ --itemCount;
+ return item;
+} //-- remove
+
+void txList::clear() {
+ ListItem* item = firstItem;
+ while (item) {
+ ListItem* tItem = item;
+ item = item->nextItem;
+ delete tItem;
+ }
+ firstItem = 0;
+ lastItem = 0;
+ itemCount = 0;
+}
+
+//------------------------------------/
+//- Implementation of txListIterator -/
+//------------------------------------/
+
+/**
+ * Creates a new txListIterator for the given txList
+ * @param list, the txList to create an Iterator for
+ **/
+txListIterator::txListIterator(txList* list) {
+ this->list = list;
+ currentItem = 0;
+ atEndOfList = false;
+} //-- txListIterator
+
+/**
+ * Adds the Object pointer to the txList pointed to by this txListIterator.
+ * The Object pointer is inserted as the next item in the txList
+ * based on the current position within the txList
+ * @param objPtr the Object pointer to add to the list
+ **/
+void txListIterator::addAfter(void* objPtr) {
+ if (currentItem || !atEndOfList) {
+ list->insertAfter(objPtr, currentItem);
+ } else {
+ list->insertBefore(objPtr, nullptr);
+ }
+} //-- addAfter
+
+/**
+ * Adds the Object pointer to the txList pointed to by this txListIterator.
+ * The Object pointer is inserted as the previous item in the txList
+ * based on the current position within the txList
+ * @param objPtr the Object pointer to add to the list
+ **/
+void txListIterator::addBefore(void* objPtr) {
+ if (currentItem || atEndOfList) {
+ list->insertBefore(objPtr, currentItem);
+ } else {
+ list->insertAfter(objPtr, nullptr);
+ }
+} //-- addBefore
+
+/**
+ * Returns true if a successful call to the next() method can be made
+ * @return true if a successful call to the next() method can be made,
+ * otherwise false
+ **/
+bool txListIterator::hasNext() {
+ bool hasNext = false;
+ if (currentItem)
+ hasNext = (currentItem->nextItem != 0);
+ else if (!atEndOfList)
+ hasNext = (list->firstItem != 0);
+
+ return hasNext;
+} //-- hasNext
+
+/**
+ * Returns the next Object pointer in the list
+ **/
+void* txListIterator::next() {
+ void* obj = 0;
+ if (currentItem)
+ currentItem = currentItem->nextItem;
+ else if (!atEndOfList)
+ currentItem = list->firstItem;
+
+ if (currentItem)
+ obj = currentItem->objPtr;
+ else
+ atEndOfList = true;
+
+ return obj;
+} //-- next
+
+/**
+ * Returns the previous Object in the list
+ **/
+void* txListIterator::previous() {
+ void* obj = 0;
+
+ if (currentItem)
+ currentItem = currentItem->prevItem;
+ else if (atEndOfList)
+ currentItem = list->lastItem;
+
+ if (currentItem) obj = currentItem->objPtr;
+
+ atEndOfList = false;
+
+ return obj;
+} //-- previous
+
+/**
+ * Returns the current Object
+ **/
+void* txListIterator::current() {
+ if (currentItem) return currentItem->objPtr;
+
+ return 0;
+} //-- current
+
+/**
+ * Removes the Object last returned by the next() or previous() methods;
+ * @return the removed Object pointer
+ **/
+void* txListIterator::remove() {
+ void* obj = 0;
+ if (currentItem) {
+ obj = currentItem->objPtr;
+ txList::ListItem* item = currentItem;
+ previous(); //-- make previous item the current item
+ list->remove(item);
+ delete item;
+ }
+ return obj;
+} //-- remove
+
+/**
+ * Resets the current location within the txList to the beginning of the txList
+ **/
+void txListIterator::reset() {
+ atEndOfList = false;
+ currentItem = 0;
+} //-- reset
+
+/**
+ * Move the iterator to right after the last element
+ **/
+void txListIterator::resetToEnd() {
+ atEndOfList = true;
+ currentItem = 0;
+} //-- moveToEnd
diff --git a/dom/xslt/base/txList.h b/dom/xslt/base/txList.h
new file mode 100644
index 0000000000..eeafd12dda
--- /dev/null
+++ b/dom/xslt/base/txList.h
@@ -0,0 +1,152 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef TRANSFRMX_LIST_H
+#define TRANSFRMX_LIST_H
+
+#include "txCore.h"
+
+class txListIterator;
+
+/**
+ * Represents an ordered list of Object pointers. Modeled after a Java 2 List.
+ **/
+class txList : public txObject {
+ friend class txListIterator;
+
+ public:
+ /**
+ * Creates an empty txList
+ **/
+ txList();
+
+ /**
+ * txList destructor, object references will not be deleted.
+ **/
+ ~txList();
+
+ /**
+ * Returns the number of items in this txList
+ **/
+ int32_t getLength();
+
+ /**
+ * Returns true if there are no items in this txList
+ */
+ inline bool isEmpty() { return itemCount == 0; }
+
+ /**
+ * Adds the given Object to the list
+ **/
+ void add(void* objPtr);
+
+ /*
+ * Removes all the objects from the list
+ */
+ void clear();
+
+ protected:
+ struct ListItem {
+ ListItem* nextItem;
+ ListItem* prevItem;
+ void* objPtr;
+ };
+
+ /**
+ * Removes the given ListItem pointer from the list
+ **/
+ ListItem* remove(ListItem* sItem);
+
+ private:
+ txList(const txList& aOther); // not implemented
+
+ ListItem* firstItem;
+ ListItem* lastItem;
+ int32_t itemCount;
+
+ void insertAfter(void* objPtr, ListItem* sItem);
+ void insertBefore(void* objPtr, ListItem* sItem);
+};
+
+/**
+ * An Iterator for the txList Class
+ **/
+class txListIterator {
+ public:
+ /**
+ * Creates a new txListIterator for the given txList
+ * @param list, the txList to create an Iterator for
+ **/
+ explicit txListIterator(txList* list);
+
+ /**
+ * Adds the Object pointer to the txList pointed to by this txListIterator.
+ * The Object pointer is inserted as the next item in the txList
+ * based on the current position within the txList
+ * @param objPtr the Object pointer to add to the list
+ **/
+ void addAfter(void* objPtr);
+
+ /**
+ * Adds the Object pointer to the txList pointed to by this txListIterator.
+ * The Object pointer is inserted as the previous item in the txList
+ * based on the current position within the txList
+ * @param objPtr the Object pointer to add to the list
+ **/
+ void addBefore(void* objPtr);
+
+ /**
+ * Returns true if a successful call to the next() method can be made
+ * @return true if a successful call to the next() method can be made,
+ * otherwise false
+ **/
+ bool hasNext();
+
+ /**
+ * Returns the next Object pointer from the list
+ **/
+ void* next();
+
+ /**
+ * Returns the previous Object pointer from the list
+ **/
+ void* previous();
+
+ /**
+ * Returns the current Object
+ **/
+ void* current();
+
+ /**
+ * Removes the Object last returned by the next() or previous() methods;
+ * @return the removed Object pointer
+ **/
+ void* remove();
+
+ /**
+ * Resets the current location within the txList to the beginning of the
+ * txList
+ **/
+ void reset();
+
+ /**
+ * Resets the current location within the txList to the end of the txList
+ **/
+ void resetToEnd();
+
+ private:
+ //-- points to the current list item
+ txList::ListItem* currentItem;
+
+ //-- points to the list to iterator over
+ txList* list;
+
+ //-- we've moved off the end of the list
+ bool atEndOfList;
+};
+
+using List = txList;
+
+#endif
diff --git a/dom/xslt/base/txLog.h b/dom/xslt/base/txLog.h
new file mode 100644
index 0000000000..c5b03ca83e
--- /dev/null
+++ b/dom/xslt/base/txLog.h
@@ -0,0 +1,23 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef txLog_h__
+#define txLog_h__
+
+#include "mozilla/Logging.h"
+
+class txLog {
+ public:
+ static mozilla::LazyLogModule xpath;
+ static mozilla::LazyLogModule xslt;
+};
+
+#define TX_LG_IMPL \
+ mozilla::LazyLogModule txLog::xpath("xpath"); \
+ mozilla::LazyLogModule txLog::xslt("xslt");
+
+#define TX_LG_CREATE
+
+#endif
diff --git a/dom/xslt/base/txNamespaceMap.cpp b/dom/xslt/base/txNamespaceMap.cpp
new file mode 100644
index 0000000000..284e08a705
--- /dev/null
+++ b/dom/xslt/base/txNamespaceMap.cpp
@@ -0,0 +1,81 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txNamespaceMap.h"
+#include "nsGkAtoms.h"
+#include "txXPathNode.h"
+
+txNamespaceMap::txNamespaceMap() = default;
+
+txNamespaceMap::txNamespaceMap(const txNamespaceMap& aOther)
+ : mPrefixes(aOther.mPrefixes.Clone()),
+ mNamespaces(aOther.mNamespaces.Clone()) {}
+
+nsresult txNamespaceMap::mapNamespace(nsAtom* aPrefix,
+ const nsAString& aNamespaceURI) {
+ nsAtom* prefix = aPrefix == nsGkAtoms::_empty ? nullptr : aPrefix;
+
+ int32_t nsId;
+ if (prefix && aNamespaceURI.IsEmpty()) {
+ // Remove the mapping
+ int32_t index = mPrefixes.IndexOf(prefix);
+ if (index >= 0) {
+ mPrefixes.RemoveElementAt(index);
+ mNamespaces.RemoveElementAt(index);
+ }
+
+ return NS_OK;
+ }
+
+ if (aNamespaceURI.IsEmpty()) {
+ // Set default to empty namespace
+ nsId = kNameSpaceID_None;
+ } else {
+ nsId = txNamespaceManager::getNamespaceID(aNamespaceURI);
+ NS_ENSURE_FALSE(nsId == kNameSpaceID_Unknown, NS_ERROR_FAILURE);
+ }
+
+ // Check if the mapping already exists
+ int32_t index = mPrefixes.IndexOf(prefix);
+ if (index >= 0) {
+ mNamespaces.ElementAt(index) = nsId;
+
+ return NS_OK;
+ }
+
+ // New mapping
+ mPrefixes.AppendElement(prefix);
+ mNamespaces.AppendElement(nsId);
+
+ return NS_OK;
+}
+
+int32_t txNamespaceMap::lookupNamespace(nsAtom* aPrefix) {
+ if (aPrefix == nsGkAtoms::xml) {
+ return kNameSpaceID_XML;
+ }
+
+ nsAtom* prefix = aPrefix == nsGkAtoms::_empty ? 0 : aPrefix;
+
+ int32_t index = mPrefixes.IndexOf(prefix);
+ if (index >= 0) {
+ return mNamespaces.SafeElementAt(index, kNameSpaceID_Unknown);
+ }
+
+ if (!prefix) {
+ return kNameSpaceID_None;
+ }
+
+ return kNameSpaceID_Unknown;
+}
+
+int32_t txNamespaceMap::lookupNamespaceWithDefault(const nsAString& aPrefix) {
+ RefPtr<nsAtom> prefix = NS_Atomize(aPrefix);
+ if (prefix != nsGkAtoms::_poundDefault) {
+ return lookupNamespace(prefix);
+ }
+
+ return lookupNamespace(nullptr);
+}
diff --git a/dom/xslt/base/txNamespaceMap.h b/dom/xslt/base/txNamespaceMap.h
new file mode 100644
index 0000000000..e2be7ebf15
--- /dev/null
+++ b/dom/xslt/base/txNamespaceMap.h
@@ -0,0 +1,38 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef TRANSFRMX_TXNAMESPACEMAP_H
+#define TRANSFRMX_TXNAMESPACEMAP_H
+
+#include "nsAtom.h"
+#include "nsCOMPtr.h"
+#include "nsTArray.h"
+
+class txNamespaceMap {
+ public:
+ txNamespaceMap();
+ txNamespaceMap(const txNamespaceMap& aOther);
+
+ nsrefcnt AddRef() { return ++mRefCnt; }
+ nsrefcnt Release() {
+ if (--mRefCnt == 0) {
+ mRefCnt = 1; // stabilize
+ delete this;
+ return 0;
+ }
+ return mRefCnt;
+ }
+
+ nsresult mapNamespace(nsAtom* aPrefix, const nsAString& aNamespaceURI);
+ int32_t lookupNamespace(nsAtom* aPrefix);
+ int32_t lookupNamespaceWithDefault(const nsAString& aPrefix);
+
+ private:
+ nsAutoRefCnt mRefCnt;
+ nsTArray<RefPtr<nsAtom>> mPrefixes;
+ nsTArray<int32_t> mNamespaces;
+};
+
+#endif // TRANSFRMX_TXNAMESPACEMAP_H
diff --git a/dom/xslt/base/txOwningArray.h b/dom/xslt/base/txOwningArray.h
new file mode 100644
index 0000000000..f25015a597
--- /dev/null
+++ b/dom/xslt/base/txOwningArray.h
@@ -0,0 +1,29 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef txOwningArray_h__
+#define txOwningArray_h__
+
+// Class acting like a nsTArray except that it deletes its objects
+// on destruction. It does not however delete its objects on operations
+// like RemoveElementsAt or on |array[i] = bar|.
+
+template <class E>
+class txOwningArray : public nsTArray<E*> {
+ public:
+ typedef nsTArray<E*> base_type;
+ typedef typename base_type::value_type value_type;
+
+ ~txOwningArray() {
+ value_type* iter = base_type::Elements();
+ value_type* end = iter + base_type::Length();
+ for (; iter < end; ++iter) {
+ delete *iter;
+ }
+ }
+};
+
+#endif // txOwningArray_h__
diff --git a/dom/xslt/base/txStack.h b/dom/xslt/base/txStack.h
new file mode 100644
index 0000000000..9a9269ed69
--- /dev/null
+++ b/dom/xslt/base/txStack.h
@@ -0,0 +1,99 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef txStack_h___
+#define txStack_h___
+
+#include "nsTArray.h"
+
+class txStack : private nsTArray<void*> {
+ public:
+ /**
+ * Returns the specified object from the top of this stack,
+ * without removing it from the stack.
+ *
+ * @return a pointer to the object that is the top of this stack.
+ */
+ inline void* peek() {
+ NS_ASSERTION(!isEmpty(), "peeking at empty stack");
+ return !isEmpty() ? ElementAt(Length() - 1) : nullptr;
+ }
+
+ /**
+ * Adds the specified object to the top of this stack.
+ *
+ * @param obj a pointer to the object that is to be added to the
+ * top of this stack.
+ */
+ inline void push(void* aObject) { AppendElement(aObject); }
+
+ /**
+ * Removes and returns the specified object from the top of this
+ * stack.
+ *
+ * @return a pointer to the object that was the top of this stack.
+ */
+ inline void* pop() {
+ void* object = nullptr;
+ NS_ASSERTION(!isEmpty(), "popping from empty stack");
+ if (!isEmpty()) {
+ object = PopLastElement();
+ }
+ return object;
+ }
+
+ /**
+ * Returns true if there are no objects in the stack.
+ *
+ * @return true if there are no objects in the stack.
+ */
+ inline bool isEmpty() { return IsEmpty(); }
+
+ /**
+ * Returns the number of elements in the Stack.
+ *
+ * @return the number of elements in the Stack.
+ */
+ inline int32_t size() { return Length(); }
+
+ private:
+ friend class txStackIterator;
+};
+
+class txStackIterator {
+ public:
+ /**
+ * Creates an iterator for the given stack.
+ *
+ * @param aStack the stack to create an iterator for.
+ */
+ inline explicit txStackIterator(txStack* aStack)
+ : mStack(aStack), mPosition(0) {}
+
+ /**
+ * Returns true if there is more objects on the stack.
+ *
+ * @return .
+ */
+ inline bool hasNext() { return (mPosition < mStack->Length()); }
+
+ /**
+ * Returns the next object pointer from the stack.
+ *
+ * @return .
+ */
+ inline void* next() {
+ if (mPosition == mStack->Length()) {
+ return nullptr;
+ }
+ return mStack->ElementAt(mPosition++);
+ }
+
+ private:
+ txStack* mStack;
+ uint32_t mPosition;
+};
+
+#endif /* txStack_h___ */
diff --git a/dom/xslt/base/txStringUtils.h b/dom/xslt/base/txStringUtils.h
new file mode 100644
index 0000000000..2064c01720
--- /dev/null
+++ b/dom/xslt/base/txStringUtils.h
@@ -0,0 +1,28 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef txStringUtils_h__
+#define txStringUtils_h__
+
+#include "nsAString.h"
+#include "nsAtom.h"
+#include "nsUnicharUtils.h"
+#include "nsContentUtils.h" // For ASCIIToLower().
+
+/**
+ * Check equality between a string and an atom containing ASCII.
+ */
+inline bool TX_StringEqualsAtom(const nsAString& aString, nsAtom* aAtom) {
+ return aAtom->Equals(aString);
+}
+
+inline already_AddRefed<nsAtom> TX_ToLowerCaseAtom(nsAtom* aAtom) {
+ nsAutoString str;
+ aAtom->ToString(str);
+ nsContentUtils::ASCIIToLower(str);
+ return NS_Atomize(str);
+}
+
+#endif // txStringUtils_h__
diff --git a/dom/xslt/base/txURIUtils.cpp b/dom/xslt/base/txURIUtils.cpp
new file mode 100644
index 0000000000..bbb06221cf
--- /dev/null
+++ b/dom/xslt/base/txURIUtils.cpp
@@ -0,0 +1,87 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txURIUtils.h"
+#include "nsNetUtil.h"
+#include "mozilla/dom/Document.h"
+#include "nsIPrincipal.h"
+#include "mozilla/LoadInfo.h"
+#include "mozilla/dom/nsCSPContext.h"
+
+using mozilla::dom::Document;
+using mozilla::net::LoadInfo;
+
+/**
+ * URIUtils
+ * A set of utilities for handling URIs
+ **/
+
+/**
+ * Resolves the given href argument, using the given documentBase
+ * if necessary.
+ * The new resolved href will be appended to the given dest String
+ **/
+void URIUtils::resolveHref(const nsAString& href, const nsAString& base,
+ nsAString& dest) {
+ if (base.IsEmpty()) {
+ dest.Append(href);
+ return;
+ }
+ if (href.IsEmpty()) {
+ dest.Append(base);
+ return;
+ }
+ nsCOMPtr<nsIURI> pURL;
+ nsAutoString resultHref;
+ nsresult result = NS_NewURI(getter_AddRefs(pURL), base);
+ if (NS_SUCCEEDED(result)) {
+ NS_MakeAbsoluteURI(resultHref, href, pURL);
+ dest.Append(resultHref);
+ }
+} //-- resolveHref
+
+// static
+void URIUtils::ResetWithSource(Document* aNewDoc, nsINode* aSourceNode) {
+ nsCOMPtr<Document> sourceDoc = aSourceNode->OwnerDoc();
+ nsIPrincipal* sourcePrincipal = sourceDoc->NodePrincipal();
+ nsIPrincipal* sourcePartitionedPrincipal = sourceDoc->PartitionedPrincipal();
+
+ // Copy the channel and loadgroup from the source document.
+ nsCOMPtr<nsILoadGroup> loadGroup = sourceDoc->GetDocumentLoadGroup();
+ nsCOMPtr<nsIChannel> channel = sourceDoc->GetChannel();
+ if (!channel) {
+ // Need to synthesize one
+ nsresult rv = NS_NewChannel(
+ getter_AddRefs(channel), sourceDoc->GetDocumentURI(), sourceDoc,
+ nsILoadInfo::SEC_FORCE_INHERIT_PRINCIPAL, nsIContentPolicy::TYPE_OTHER,
+ nullptr, // aPerformanceStorage
+ loadGroup,
+ nullptr, // aCallbacks
+ nsIChannel::LOAD_BYPASS_SERVICE_WORKER);
+
+ if (NS_FAILED(rv)) {
+ return;
+ }
+ }
+
+ aNewDoc->Reset(channel, loadGroup);
+ aNewDoc->SetPrincipals(sourcePrincipal, sourcePartitionedPrincipal);
+ aNewDoc->SetBaseURI(sourceDoc->GetDocBaseURI());
+ aNewDoc->SetSandboxFlags(sourceDoc->GetSandboxFlags());
+ aNewDoc->SetReferrerInfo(sourceDoc->GetReferrerInfo());
+ aNewDoc->SetEmbedderPolicy(sourceDoc->GetEmbedderPolicy());
+
+ // Inherit the csp if there is one
+ nsCOMPtr<nsIContentSecurityPolicy> csp = sourceDoc->GetCsp();
+ if (csp) {
+ RefPtr<nsCSPContext> cspToInherit = new nsCSPContext();
+ cspToInherit->InitFromOther(static_cast<nsCSPContext*>(csp.get()));
+ aNewDoc->SetCsp(cspToInherit);
+ }
+ // Copy charset
+ aNewDoc->SetDocumentCharacterSetSource(
+ sourceDoc->GetDocumentCharacterSetSource());
+ aNewDoc->SetDocumentCharacterSet(sourceDoc->GetDocumentCharacterSet());
+}
diff --git a/dom/xslt/base/txURIUtils.h b/dom/xslt/base/txURIUtils.h
new file mode 100644
index 0000000000..96082b99f7
--- /dev/null
+++ b/dom/xslt/base/txURIUtils.h
@@ -0,0 +1,40 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef TRANSFRMX_URIUTILS_H
+#define TRANSFRMX_URIUTILS_H
+
+#include "txCore.h"
+
+class nsINode;
+
+namespace mozilla::dom {
+class Document;
+} // namespace mozilla::dom
+
+/**
+ * A utility class for URI handling
+ * Not yet finished, only handles file URI at this point
+ **/
+
+class URIUtils {
+ public:
+ /**
+ * Reset the given document with the document of the source node
+ */
+ static void ResetWithSource(mozilla::dom::Document* aNewDoc,
+ nsINode* aSourceNode);
+
+ /**
+ * Resolves the given href argument, using the given documentBase
+ * if necessary.
+ * The new resolved href will be appended to the given dest String
+ **/
+ static void resolveHref(const nsAString& href, const nsAString& base,
+ nsAString& dest);
+}; //-- URIUtils
+
+/* */
+#endif
diff --git a/dom/xslt/crashtests/1089049.html b/dom/xslt/crashtests/1089049.html
new file mode 100644
index 0000000000..84ef6494c3
--- /dev/null
+++ b/dom/xslt/crashtests/1089049.html
@@ -0,0 +1,3 @@
+<script>
+var xpathResult = document.evaluate('', null, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
+</script>
diff --git a/dom/xslt/crashtests/111994.xml b/dom/xslt/crashtests/111994.xml
new file mode 100644
index 0000000000..ce7ffad2ac
--- /dev/null
+++ b/dom/xslt/crashtests/111994.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" standalone="yes" ?>
+<?xml-stylesheet type="text/xsl" href="111994.xsl" ?>
+<root>
+ <item id="1001" name="name" />
+</root>
diff --git a/dom/xslt/crashtests/111994.xsl b/dom/xslt/crashtests/111994.xsl
new file mode 100644
index 0000000000..4cf68179fa
--- /dev/null
+++ b/dom/xslt/crashtests/111994.xsl
@@ -0,0 +1,13 @@
+<?xml version="1.0" ?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+ <xsl:template match="root">
+ <html><body><xsl:apply-templates select="item" /></body></html>
+ </xsl:template>
+ <xsl:template match="item">
+ <img>
+ <xsl:attribute name="src">
+ <xsl:value-of select="@name" />
+ </xsl:attribute>
+ </img>
+ </xsl:template>
+</xsl:stylesheet>
diff --git a/dom/xslt/crashtests/1205163.xml b/dom/xslt/crashtests/1205163.xml
new file mode 100644
index 0000000000..2d450a1d50
--- /dev/null
+++ b/dom/xslt/crashtests/1205163.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0"?>
+<?xml-stylesheet type="text/xsl" href="1205163.xsl"?>
+<result>
+ <Title>Example</Title>
+ <Error>Error</Error>
+</result>
diff --git a/dom/xslt/crashtests/1205163.xsl b/dom/xslt/crashtests/1205163.xsl
new file mode 100644
index 0000000000..f0bbb5cb95
--- /dev/null
+++ b/dom/xslt/crashtests/1205163.xsl
@@ -0,0 +1,11 @@
+<?xml version="1.0"?>
+<xsl:stylesheet version="1.0"
+ xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+ <xsl:output method="text"/>
+ <xsl:template match="node()|@*">
+ <xsl:copy>
+ <xsl:apply-templates select="node()|@*"/>
+ </xsl:copy>
+ </xsl:template>
+ <xsl:template match="Error"/>
+</xsl:stylesheet>
diff --git a/dom/xslt/crashtests/1243337.xml b/dom/xslt/crashtests/1243337.xml
new file mode 100644
index 0000000000..40f5e3a35d
--- /dev/null
+++ b/dom/xslt/crashtests/1243337.xml
@@ -0,0 +1,3 @@
+<?xml version="1.0" standalone="yes" ?>
+<?xml-stylesheet type="text/xsl" href="1243337.xsl" ?>
+<root/>
diff --git a/dom/xslt/crashtests/1243337.xsl b/dom/xslt/crashtests/1243337.xsl
new file mode 100644
index 0000000000..0e659bf900
--- /dev/null
+++ b/dom/xslt/crashtests/1243337.xsl
@@ -0,0 +1,6 @@
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+ <xsl:template match="/">
+ <xsl:value-of select="generate-id(5)"/>
+ <html><body/></html>
+ </xsl:template>
+</xsl:stylesheet>
diff --git a/dom/xslt/crashtests/1330492.html b/dom/xslt/crashtests/1330492.html
new file mode 100644
index 0000000000..a19c646a17
--- /dev/null
+++ b/dom/xslt/crashtests/1330492.html
@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+<html>
+<meta charset="UTF-8">
+<script id=o_xml type="text/plain"><?xml version="1.0" encoding="UTF-8"?>
+<ffsy></ffsy>
+</script>
+<script id=o_xslt type="text/plain"><?xml version="1.0" encoding="UTF-8"?>
+<xsl:transform xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+ <xsl:output method="text" />
+</xsl:transform>
+</script>
+<script>
+addEventListener("DOMContentLoaded", function(){
+ let doc = new DOMParser();
+ let xml = doc.parseFromString(o_xml.textContent, "text/xml");
+ let xsltPrs = new XSLTProcessor();
+ let xsl = doc.parseFromString(o_xslt.textContent, "text/xml");
+ xsltPrs.importStylesheet(xsl);
+ xsltPrs.transformToFragment(xml, document);
+ xsltPrs.transformToDocument(xml);
+});
+</script>
+</html>
diff --git a/dom/xslt/crashtests/1336828.html b/dom/xslt/crashtests/1336828.html
new file mode 100644
index 0000000000..3f25e23e03
--- /dev/null
+++ b/dom/xslt/crashtests/1336828.html
@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="UTF-8">
+<script id=o_xml type="text/plain"><?xml version="1.0" encoding="UTF-8"?>
+<tag_name/>
+</script>
+<script id=o_xslt type="text/plain"><?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="42">
+ <xsl:variable name="var_name"><xsl:template/></xsl:variable>
+ <xsl:template match="tag_name[$var_name]"/>
+</xsl:stylesheet>
+</script>
+<script>
+window.onload = function(){
+ let doc = new DOMParser(), proc = new XSLTProcessor();
+ proc.importStylesheet(doc.parseFromString(document.getElementById('o_xslt').textContent, "text/xml"));
+ proc.transformToDocument(doc.parseFromString(document.getElementById('o_xml').textContent, "text/xml"));
+};
+</script>
+</head>
+</html>
diff --git a/dom/xslt/crashtests/1336830.html b/dom/xslt/crashtests/1336830.html
new file mode 100644
index 0000000000..907f589563
--- /dev/null
+++ b/dom/xslt/crashtests/1336830.html
@@ -0,0 +1,27 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="UTF-8">
+<script id=o_xml type="text/plain"><?xml version="1.0" encoding="UTF-8"?>
+<tag_name/>
+</script>
+<script id=o_xslt type="text/plain"><?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="42">
+ <xsl:template match="*">
+ <xsl:apply-imports/>
+ <xsl:apply-templates select=".">
+ <xsl:with-param name="whatever_1">whatever_2</xsl:with-param>
+ </xsl:apply-templates>
+ </xsl:template>
+</xsl:stylesheet>
+</script>
+<script>
+window.onload = function(){
+ setTimeout(function(){ window.close(); }, 400);
+ let doc = new DOMParser(), proc = new XSLTProcessor();
+ proc.importStylesheet(doc.parseFromString(document.getElementById('o_xslt').textContent, "text/xml"));
+ proc.transformToFragment(doc.parseFromString(document.getElementById('o_xml').textContent, "text/xml"), document);
+};
+</script>
+</head>
+</html>
diff --git a/dom/xslt/crashtests/1336832.html b/dom/xslt/crashtests/1336832.html
new file mode 100644
index 0000000000..0fb9033d1a
--- /dev/null
+++ b/dom/xslt/crashtests/1336832.html
@@ -0,0 +1,28 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="UTF-8">
+<script id=o_xml type="text/plain"><?xml version="1.0" encoding="UTF-8"?>
+<tag_name/>
+</script>
+<script id=o_xslt type="text/plain"><?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+ <xsl:variable name="var_1">
+ <xsl:for-each select="/">
+ <xsl:value-of select="count()"/>
+ </xsl:for-each>
+ </xsl:variable>
+ <xsl:template match="/">
+ <xsl:value-of select="//*[1 = $var_1]"/>
+ </xsl:template>
+</xsl:stylesheet>
+</script>
+<script>
+window.onload = function(){
+ let doc = new DOMParser(), proc = new XSLTProcessor();
+ proc.importStylesheet(doc.parseFromString(document.getElementById('o_xslt').textContent, "text/xml"));
+ proc.transformToDocument(doc.parseFromString(document.getElementById('o_xml').textContent, "text/xml"));
+};
+</script>
+</head>
+</html>
diff --git a/dom/xslt/crashtests/1338277.html b/dom/xslt/crashtests/1338277.html
new file mode 100644
index 0000000000..d928819c75
--- /dev/null
+++ b/dom/xslt/crashtests/1338277.html
@@ -0,0 +1,21 @@
+<script id=o_xml type="text/plain"><?xml version="1.0" encoding="UTF-8"?>
+<xb></xb>
+</script>
+<script id=o_xslt type="text/plain"><?xml version="1.0" encoding="UTF-8"?>
+<xsl:transform version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+ <xsl:template match="xb[$v1]"></xsl:template>
+ <xsl:variable name="v1">
+ <xsl:attribute name="a1" namespace="z">
+ <xsl:variable name="v2" select="$v2"></xsl:variable>
+ </xsl:attribute>
+ </xsl:variable>
+</xsl:transform>
+</script>
+<script>
+addEventListener("DOMContentLoaded", function(){
+ let doc = new DOMParser();
+ let xsltPrs = new XSLTProcessor();
+ xsltPrs.importStylesheet(doc.parseFromString(o_xslt.textContent, "text/xml"));
+ xsltPrs.transformToDocument(doc.parseFromString(o_xml.textContent, "text/xml"));
+});
+</script>
diff --git a/dom/xslt/crashtests/1361892.html b/dom/xslt/crashtests/1361892.html
new file mode 100644
index 0000000000..a7befd2c42
--- /dev/null
+++ b/dom/xslt/crashtests/1361892.html
@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta charset="UTF-8">
+ <script id=o_xml type="text/plain"><?xml version="1.0" encoding="UTF-8"?>
+<tag_name/>
+ </script>
+ <script id=o_xslt type="text/plain"><?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="42">
+ <xsl:template match="*">
+ <xsl:value-of xmlns:regexp="http://exslt.org/regular-expressions" select="regexp:match('foo','bar','-2')"/>
+ </xsl:template>
+</xsl:stylesheet>
+ </script>
+ <script>
+window.onload = function(){
+ let doc = new DOMParser(), proc = new XSLTProcessor();
+ proc.importStylesheet(doc.parseFromString(document.getElementById('o_xslt').textContent, "text/xml"));
+ proc.transformToDocument(doc.parseFromString(document.getElementById('o_xml').textContent, "text/xml"));
+};
+ </script>
+ </head>
+</html>
diff --git a/dom/xslt/crashtests/1430818.sjs b/dom/xslt/crashtests/1430818.sjs
new file mode 100644
index 0000000000..a1c9f1e662
--- /dev/null
+++ b/dom/xslt/crashtests/1430818.sjs
@@ -0,0 +1,49 @@
+function getFileStream(filename)
+{
+ let self = Components.classes["@mozilla.org/file/local;1"]
+ .createInstance(Components.interfaces.nsIFile);
+ self.initWithPath(getState("__LOCATION__"));
+ let file = self.parent;
+ file.append(filename);
+ let stream = Components.classes['@mozilla.org/network/file-input-stream;1']
+ .createInstance(Components.interfaces.nsIFileInputStream);
+ stream.init(file, -1, -1, false);
+ return stream;
+}
+
+function handleRequest(request, response)
+{
+ response.processAsync();
+ response.setStatusLine(null, 200, "OK");
+ response.setHeader("Content-Type", "text/xml", false);
+
+ switch (request.queryString) {
+ case "stylesheet":
+ {
+ let timer = Components.classes["@mozilla.org/timer;1"]
+ .createInstance(Components.interfaces.nsITimer);
+ timer.initWithCallback(() => {
+ setState("xslt", "loaded");
+ response.finish();
+ timer.cancel();
+ }, 1000 /* milliseconds */, Components.interfaces.nsITimer.TYPE_REPEATING_SLACK);
+ break;
+ }
+ default:
+ {
+ let stream = getFileStream("1430818.xml");
+ response.bodyOutputStream.writeFrom(stream,
+ stream.available());
+ stream.close();
+ let timer = Components.classes["@mozilla.org/timer;1"]
+ .createInstance(Components.interfaces.nsITimer);
+ timer.initWithCallback(() => {
+ if (getState("xslt") == "loaded") {
+ response.finish();
+ timer.cancel();
+ }
+ }, 100 /* milliseconds */, Components.interfaces.nsITimer.TYPE_REPEATING_SLACK);
+ break;
+ }
+ }
+}
diff --git a/dom/xslt/crashtests/1430818.xml b/dom/xslt/crashtests/1430818.xml
new file mode 100644
index 0000000000..95731bcb0b
--- /dev/null
+++ b/dom/xslt/crashtests/1430818.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0"?>
+<?xml-stylesheet type="text/xsl" href="?stylesheet"?>
+<root>
+</root>
diff --git a/dom/xslt/crashtests/1527277.html b/dom/xslt/crashtests/1527277.html
new file mode 100644
index 0000000000..ef437803c9
--- /dev/null
+++ b/dom/xslt/crashtests/1527277.html
@@ -0,0 +1,14 @@
+<html>
+<script>
+var xml = "<e/>";
+var xsl = "<xsl:stylesheet version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\"><xsl:decimal-format grouping-separator=\".\" /><xsl:template match=\"/\"><xsl:value-of select=\"format-number(0.1, '.#')\"/></xsl:template></xsl:stylesheet>";
+
+var parser = new DOMParser();
+var xmlDoc = parser.parseFromString(xml, "text/xml");
+var xslDoc = parser.parseFromString(xsl, "text/xml");
+
+xsltProcessor = new XSLTProcessor();
+xsltProcessor.importStylesheet(xslDoc);
+var result = xsltProcessor.transformToDocument(xmlDoc);
+</script>
+</html>
diff --git a/dom/xslt/crashtests/1589930.xml b/dom/xslt/crashtests/1589930.xml
new file mode 100644
index 0000000000..74d4cc8463
--- /dev/null
+++ b/dom/xslt/crashtests/1589930.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0"?>
+<?xml-stylesheet type="text/xsl" href="#stylesheet"?>
+<!DOCTYPE root [
+ <!ATTLIST xsl:stylesheet id ID #IMPLIED>
+]>
+<root>
+<xsl:stylesheet id="stylesheet" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+ <xsl:template match="/"><xsl:value-of select="format-number(99.98, '0.0')"/></xsl:template>
+</xsl:stylesheet>
+</root>
diff --git a/dom/xslt/crashtests/182460-select.xml b/dom/xslt/crashtests/182460-select.xml
new file mode 100644
index 0000000000..bb9f79b040
--- /dev/null
+++ b/dom/xslt/crashtests/182460-select.xml
@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<?xml-stylesheet type="text/xsl" href="182460-selects.xsl"?>
+<fud/> \ No newline at end of file
diff --git a/dom/xslt/crashtests/182460-selects.xsl b/dom/xslt/crashtests/182460-selects.xsl
new file mode 100644
index 0000000000..f083ea31fe
--- /dev/null
+++ b/dom/xslt/crashtests/182460-selects.xsl
@@ -0,0 +1,5 @@
+<html>
+<body>
+hi
+</body>
+</html>
diff --git a/dom/xslt/crashtests/182460-table.xhtml b/dom/xslt/crashtests/182460-table.xhtml
new file mode 100644
index 0000000000..1bf2a23cb4
--- /dev/null
+++ b/dom/xslt/crashtests/182460-table.xhtml
@@ -0,0 +1,9 @@
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<title>XSL Crash</title>
+</head>
+<body>
+<iframe src="182460-select.xml"></iframe>
+<script type="text/javascript" src="data:text/javascript,/*no code*/"/>
+</body>
+</html>
diff --git a/dom/xslt/crashtests/226425.xml b/dom/xslt/crashtests/226425.xml
new file mode 100644
index 0000000000..c6662cfe2c
--- /dev/null
+++ b/dom/xslt/crashtests/226425.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<?xml-stylesheet type="text/xsl" href="226425.xsl" ?>
+
+<text></text>
diff --git a/dom/xslt/crashtests/226425.xsl b/dom/xslt/crashtests/226425.xsl
new file mode 100644
index 0000000000..ddb61ae680
--- /dev/null
+++ b/dom/xslt/crashtests/226425.xsl
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+<xsl:output method="html" indent="yes"/>
+
+<xsl:template match="/">
+<html><body>
+<xsl:apply-templates select="document('dontmatter')"/>
+</body></html>
+</xsl:template>
+</xsl:stylesheet>
diff --git a/dom/xslt/crashtests/406106-1.html b/dom/xslt/crashtests/406106-1.html
new file mode 100644
index 0000000000..86ab510ff8
--- /dev/null
+++ b/dom/xslt/crashtests/406106-1.html
@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html>
+<head>
+<script type="text/javascript">
+
+function boom()
+{
+ var p = new XSLTProcessor();
+ p.setParameter("a", "b", {e: p});
+}
+
+boom();
+
+</script>
+</head>
+<body>
+</body>
+</html>
diff --git a/dom/xslt/crashtests/483444.xml b/dom/xslt/crashtests/483444.xml
new file mode 100644
index 0000000000..18fffceba5
--- /dev/null
+++ b/dom/xslt/crashtests/483444.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0"?>
+<?xml-stylesheet type="text/xsl" href="#stylesheet"?>
+<!DOCTYPE root [
+ <!ATTLIST xsl:stylesheet id ID #IMPLIED>
+]>
+<root>
+<xsl:stylesheet id="stylesheet" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+ <xsl:attribute-set name="a">
+ <xsl:attribute name="b">c</xsl:attribute>
+ </xsl:attribute-set>
+ <xsl:template match="/">
+ <b>Please output something!</b>
+ </xsl:template>
+ <xsl:attribute-set name="a">
+ <xsl:attribute name="b">c</xsl:attribute>
+ </xsl:attribute-set>
+</xsl:stylesheet>
+<doc id="foo">this</doc>
+</root>
diff --git a/dom/xslt/crashtests/485217.xml b/dom/xslt/crashtests/485217.xml
new file mode 100644
index 0000000000..93a20e4f77
--- /dev/null
+++ b/dom/xslt/crashtests/485217.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?xml-stylesheet type="text/xsl" href="485217.xsl"?>
+
+
+<root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+ <item1 id="AAAAAAA" />
+ <item2 id="AAAAAAAAA" label="AAAAAAAAAAAA"/>
+</root>
diff --git a/dom/xslt/crashtests/485217.xsl b/dom/xslt/crashtests/485217.xsl
new file mode 100644
index 0000000000..2935c5a41b
--- /dev/null
+++ b/dom/xslt/crashtests/485217.xsl
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+
+ <xsl:key name="label" match="item2" use="undeclaredfunc()"/>
+
+ <xsl:template match="root">
+ <xsl:for-each select="//item1">
+ <xsl:call-template name="item1" />
+ </xsl:for-each>
+ </xsl:template>
+
+ <xsl:template name="item1">
+ <xsl:for-each select="key('label', 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA')">
+ </xsl:for-each>
+ </xsl:template>
+
+</xsl:stylesheet>
diff --git a/dom/xslt/crashtests/485286.xml b/dom/xslt/crashtests/485286.xml
new file mode 100644
index 0000000000..c87aa940ef
--- /dev/null
+++ b/dom/xslt/crashtests/485286.xml
@@ -0,0 +1,12 @@
+<?xml-stylesheet type="application/xml" href="485286.xml"?>
+<transform xmlns="http://www.w3.org/1999/XSL/Transform" version="1.0">
+ <variable name="v">
+ <for-each select="/">
+ <value-of select="count(1)"/>
+ </for-each>
+ </variable>
+ <key name="k" match="/" use="$v"/>
+ <template match="/">
+ <value-of select="key('k', /..)"/>
+ </template>
+</transform>
diff --git a/dom/xslt/crashtests/527558_1.xml b/dom/xslt/crashtests/527558_1.xml
new file mode 100644
index 0000000000..ebb6c3d533
--- /dev/null
+++ b/dom/xslt/crashtests/527558_1.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0"?>
+<?xml-stylesheet type="text/xml" href="#bug"?>
+<!DOCTYPE doc [
+<!ATTLIST xsl:transform
+ id ID #REQUIRED>
+]>
+<doc>
+<xsl:transform id="bug"
+ version="2.0"
+ xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+ <xsl:key name="k0" match="e1" use="key('k0', 'foobar')" />
+ <xsl:template id="t1" name="t1" match="key('k0', '1/2/2003')" />
+</xsl:transform>
+
+<e1 a1="foobar" a2="foobar"/>
+
+</doc>
diff --git a/dom/xslt/crashtests/528300.xml b/dom/xslt/crashtests/528300.xml
new file mode 100644
index 0000000000..8902bb373e
--- /dev/null
+++ b/dom/xslt/crashtests/528300.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0"?>
+<?xml-stylesheet type="text/xml" href="#bug"?>
+<!DOCTYPE doc [
+<!ATTLIST xsl:transform
+ id ID #REQUIRED>
+]>
+<doc>
+<xsl:transform
+ xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+ version="2.0"
+ id="bug">
+ <xsl:variable name="v0">
+ <xsl:for-each select="$v0" />
+ </xsl:variable>
+ <xsl:template name="t2" match="/">
+ <xsl:copy-of select="number($v0)" />
+ </xsl:template>
+</xsl:transform>
+
+<e1 />
+
+</doc>
diff --git a/dom/xslt/crashtests/528488.xml b/dom/xslt/crashtests/528488.xml
new file mode 100644
index 0000000000..904b345612
--- /dev/null
+++ b/dom/xslt/crashtests/528488.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0"?>
+<?xml-stylesheet type="text/xml" href="#bug"?>
+<!DOCTYPE doc [
+<!ATTLIST xsl:transform
+ id ID #REQUIRED>
+]>
+<doc>
+ <xsl:transform
+ xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+ xmlns:exslstrings="http://exslt.org/strings"
+ version="2.0"
+ id="bug">
+ <xsl:variable name="v0" select="$v0" />
+ <xsl:template name="t2" match="/">
+ <xsl:param name="p0" select="exslstrings:tokenize('1234','foobar')" />
+ <xsl:copy-of select="round($v0)" />
+ </xsl:template>
+ </xsl:transform>
+</doc>
diff --git a/dom/xslt/crashtests/528963.xml b/dom/xslt/crashtests/528963.xml
new file mode 100644
index 0000000000..d855e75634
--- /dev/null
+++ b/dom/xslt/crashtests/528963.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0"?>
+<?xml-stylesheet type="text/xml" href="#bug"?>
+<!DOCTYPE doc [
+<!ATTLIST xsl:transform
+ id ID #REQUIRED>
+]>
+<doc>
+ <xsl:transform
+ xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+ version="2.0"
+ id="bug">
+ <xsl:key name="k0" match="e2" use="name('foo')" />
+
+ <xsl:template name="t1" match="/">
+ <xsl:element name="e2" namespace="{//doc}" />
+ </xsl:template>
+ <xsl:template name="t2" match="key('k0', 'bar')" />
+ </xsl:transform>
+
+ <e2/>
+
+</doc>
diff --git a/dom/xslt/crashtests/545927.html b/dom/xslt/crashtests/545927.html
new file mode 100644
index 0000000000..0a9010e21e
--- /dev/null
+++ b/dom/xslt/crashtests/545927.html
@@ -0,0 +1,28 @@
+<html>
+<head>
+<script>
+function main()
+{
+ xml=document.implementation.createDocument('', '', null);
+ xml.appendChild(doc=xml.createElement('root'));
+
+ var p = new DOMParser();
+ text = '<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">';
+ text += '<xsl:template match="/">';
+ text += '<body>';
+ text += '<xsl:number value="2147483648" format="i"/>';
+ text += '</body>';
+ text += '</xsl:template>';
+ text += '</xsl:stylesheet>';
+ xsl=p.parseFromString(text, 'text/xml');
+
+ xsltProcessor=new XSLTProcessor();
+ xsltProcessor.importStylesheet(xsl);
+ d = xsltProcessor.transformToFragment(xml, document);
+}
+</script>
+</head>
+<body onload="main()">
+</body>
+</html>
+
diff --git a/dom/xslt/crashtests/601543.html b/dom/xslt/crashtests/601543.html
new file mode 100644
index 0000000000..af025b242a
--- /dev/null
+++ b/dom/xslt/crashtests/601543.html
@@ -0,0 +1,4 @@
+<!DOCTYPE html>
+<script>
+(new XSLTProcessor).setParameter('', '', [{}, null]);
+</script>
diff --git a/dom/xslt/crashtests/602115.html b/dom/xslt/crashtests/602115.html
new file mode 100644
index 0000000000..ad42d76a05
--- /dev/null
+++ b/dom/xslt/crashtests/602115.html
@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<script>
+
+try {
+ var docType = document.implementation.createDocumentType(undefined, '', '');
+ var doc = document.implementation.createDocument('', '', null);
+ var xp = new XSLTProcessor;
+ xp.importStylesheet(doc);
+ xp.transformToDocument(docType);
+}
+catch (ex) {}
+
+try {
+ docType = document.implementation.createDocumentType(undefined, '', '');
+ doc = document.implementation.createDocument('', '', null);
+ xp = new XSLTProcessor;
+ xp.importStylesheet(doc);
+ xp.transformToFragment(docType, document);
+}
+catch (ex) {}
+
+</script>
diff --git a/dom/xslt/crashtests/603844.html b/dom/xslt/crashtests/603844.html
new file mode 100644
index 0000000000..f576effdb6
--- /dev/null
+++ b/dom/xslt/crashtests/603844.html
@@ -0,0 +1,32 @@
+<!DOCTYPE html>
+<html class="reftest-wait">
+<head>
+<script>
+
+function boom()
+{
+ var frame = document.createElementNS("http://www.w3.org/1999/xhtml", "iframe");
+ frame.onload = y;
+ frame.src = "data:text/plain,0";
+ document.body.appendChild(frame);
+ frameDoc = frame.contentDocument;
+
+ function y()
+ {
+ frameDoc.removeChild(frameDoc.documentElement);
+
+ var xp = new XSLTProcessor;
+ xp.importStylesheet(frameDoc);
+ try {
+ xp.transformToDocument(frameDoc.createTextNode('x'));
+ } catch(e) { }
+
+ document.documentElement.removeAttribute("class");
+ }
+}
+
+</script>
+</head>
+
+<body onload="boom();"></body>
+</html>
diff --git a/dom/xslt/crashtests/667315.xml b/dom/xslt/crashtests/667315.xml
new file mode 100644
index 0000000000..7a560ba3bd
--- /dev/null
+++ b/dom/xslt/crashtests/667315.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0"?>
+<?xml-stylesheet type="text/xsl" href="#stylesheet"?>
+<!DOCTYPE root [
+ <!ATTLIST xsl:stylesheet id ID #IMPLIED>
+]>
+<root>
+<xsl:stylesheet id="stylesheet" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+ <xsl:variable name="var"><p>a</p></xsl:variable>
+ <xsl:template match="/"><xsl:copy-of select="$var" /></xsl:template>
+</xsl:stylesheet>
+</root>
diff --git a/dom/xslt/crashtests/91332.xml b/dom/xslt/crashtests/91332.xml
new file mode 100644
index 0000000000..c5a463c8a9
--- /dev/null
+++ b/dom/xslt/crashtests/91332.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" standalone="yes" ?>
+<?xml-stylesheet type="text/xsl" href="91332.xsl" ?>
+<root>
+ <category name="Rectangles">
+ <list item="square" />
+ </category>
+ <quad id="square">
+ <desc>A square is ...</desc>
+ </quad>
+</root>
diff --git a/dom/xslt/crashtests/91332.xsl b/dom/xslt/crashtests/91332.xsl
new file mode 100644
index 0000000000..7d01df22b6
--- /dev/null
+++ b/dom/xslt/crashtests/91332.xsl
@@ -0,0 +1,21 @@
+<?xml version="1.0" ?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+
+ <xsl:key name="polyList" match="quad" use="@id" />
+
+ <xsl:template match="root">
+ <html><body><xsl:apply-templates select="category" /></body></html>
+ </xsl:template>
+
+ <xsl:template match="category">
+ <table><xsl:apply-templates select="list" /></table>
+ </xsl:template>
+
+ <xsl:template match="list">
+ <tr><td><xsl:apply-templates select="key('polyList',@item)" /></td></tr>
+ </xsl:template>
+
+ <xsl:template match="quad">
+ <b>Please output something!</b>
+ </xsl:template>
+</xsl:stylesheet>
diff --git a/dom/xslt/crashtests/949990.html b/dom/xslt/crashtests/949990.html
new file mode 100644
index 0000000000..23868e4db3
--- /dev/null
+++ b/dom/xslt/crashtests/949990.html
@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="UTF-8">
+<script>
+
+function boom() {
+ document.evaluate("a", document.documentElement, null, 4096, null);
+}
+
+</script>
+</head>
+
+<body onload="boom()"></body>
+</html>
diff --git a/dom/xslt/crashtests/crashtests.list b/dom/xslt/crashtests/crashtests.list
new file mode 100644
index 0000000000..711f357862
--- /dev/null
+++ b/dom/xslt/crashtests/crashtests.list
@@ -0,0 +1,30 @@
+load 91332.xml
+load 111994.xml
+load 182460-table.xhtml
+load 226425.xml
+load 406106-1.html
+load 483444.xml
+load 485217.xml
+load 485286.xml
+load 527558_1.xml
+load 528300.xml
+load 528488.xml
+load 528963.xml
+load 545927.html
+load 601543.html
+load 602115.html
+load 603844.html
+load 667315.xml
+load 949990.html
+load 1089049.html
+load 1205163.xml
+load 1243337.xml
+load 1330492.html
+load 1336828.html
+load 1336830.html
+load 1336832.html
+load 1338277.html
+load 1361892.html
+load 1527277.html
+load 1589930.xml
+HTTP load 1430818.sjs
diff --git a/dom/xslt/moz.build b/dom/xslt/moz.build
new file mode 100644
index 0000000000..7795e7fdf9
--- /dev/null
+++ b/dom/xslt/moz.build
@@ -0,0 +1,23 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+with Files("**"):
+ BUG_COMPONENT = ("Core", "XSLT")
+
+EXPORTS += [
+ "nsIDocumentTransformer.h",
+]
+
+DIRS += [
+ "base",
+ "xml",
+ "xpath",
+ "xslt",
+]
+
+if CONFIG["ENABLE_TESTS"]:
+ MOCHITEST_MANIFESTS += ["tests/mochitest/mochitest.ini"]
+ BROWSER_CHROME_MANIFESTS += ["tests/browser/browser.ini"]
diff --git a/dom/xslt/nsIDocumentTransformer.h b/dom/xslt/nsIDocumentTransformer.h
new file mode 100644
index 0000000000..3df790dae0
--- /dev/null
+++ b/dom/xslt/nsIDocumentTransformer.h
@@ -0,0 +1,74 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsIDocumentTransformer_h__
+#define nsIDocumentTransformer_h__
+
+#include "nsISupports.h"
+#include "nsStringFwd.h"
+
+template <class>
+class nsCOMPtr;
+class nsIContent;
+class nsINode;
+class nsIURI;
+template <class>
+class nsTArray;
+
+namespace mozilla {
+namespace dom {
+class Document;
+}
+} // namespace mozilla
+
+#define NS_ITRANSFORMOBSERVER_IID \
+ { \
+ 0x04b2d17c, 0xe98d, 0x45f5, { \
+ 0x9a, 0x67, 0xb7, 0x01, 0x19, 0x59, 0x7d, 0xe7 \
+ } \
+ }
+
+class nsITransformObserver : public nsISupports {
+ public:
+ NS_DECLARE_STATIC_IID_ACCESSOR(NS_ITRANSFORMOBSERVER_IID)
+
+ virtual nsresult OnDocumentCreated(
+ mozilla::dom::Document* aSourceDocument,
+ mozilla::dom::Document* aResultDocument) = 0;
+
+ virtual nsresult OnTransformDone(mozilla::dom::Document* aSourceDocument,
+ nsresult aResult,
+ mozilla::dom::Document* aResultDocument) = 0;
+};
+
+NS_DEFINE_STATIC_IID_ACCESSOR(nsITransformObserver, NS_ITRANSFORMOBSERVER_IID)
+
+#define NS_IDOCUMENTTRANSFORMER_IID \
+ { \
+ 0xf45e1ff8, 0x50f3, 0x4496, { \
+ 0xb3, 0xa2, 0x0e, 0x03, 0xe8, 0x4a, 0x57, 0x11 \
+ } \
+ }
+
+class nsIDocumentTransformer : public nsISupports {
+ public:
+ NS_DECLARE_STATIC_IID_ACCESSOR(NS_IDOCUMENTTRANSFORMER_IID)
+
+ NS_IMETHOD SetTransformObserver(nsITransformObserver* aObserver) = 0;
+ NS_IMETHOD LoadStyleSheet(nsIURI* aUri,
+ mozilla::dom::Document* aLoaderDocument) = 0;
+ NS_IMETHOD SetSourceContentModel(nsINode* aSource) = 0;
+ NS_IMETHOD CancelLoads() = 0;
+
+ NS_IMETHOD AddXSLTParamNamespace(const nsString& aPrefix,
+ const nsString& aNamespace) = 0;
+ NS_IMETHOD AddXSLTParam(const nsString& aName, const nsString& aNamespace,
+ const nsString& aValue, const nsString& aSelect,
+ nsINode* aContextNode) = 0;
+};
+
+NS_DEFINE_STATIC_IID_ACCESSOR(nsIDocumentTransformer,
+ NS_IDOCUMENTTRANSFORMER_IID)
+
+#endif // nsIDocumentTransformer_h__
diff --git a/dom/xslt/tests/XSLTMark/XSLTMark-static.js b/dom/xslt/tests/XSLTMark/XSLTMark-static.js
new file mode 100644
index 0000000000..fcca33e72b
--- /dev/null
+++ b/dom/xslt/tests/XSLTMark/XSLTMark-static.js
@@ -0,0 +1,46 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const enablePrivilege = netscape.security.PrivilegeManager.enablePrivilege;
+const IOSERVICE_CTRID = "@mozilla.org/network/io-service;1";
+const nsIIOService = Ci.nsIIOService;
+const SIS_CTRID = "@mozilla.org/scriptableinputstream;1";
+const nsISIS = Ci.nsIScriptableInputStream;
+const nsIFilePicker = Ci.nsIFilePicker;
+const STDURLMUT_CTRID = "@mozilla.org/network/standard-url-mutator;1";
+const nsIURIMutator = Ci.nsIURIMutator;
+
+const { NetUtil } = ChromeUtils.import("resource://gre/modules/NetUtil.jsm");
+
+var gStop = false;
+
+function loadFile(aUriSpec) {
+ enablePrivilege("UniversalXPConnect");
+ var serv = Cc[IOSERVICE_CTRID].getService(nsIIOService);
+ if (!serv) {
+ throw Components.Exception("", Cr.ERR_FAILURE);
+ }
+ var chan = NetUtil.newChannel({
+ uri: aUriSpec,
+ loadUsingSystemPrincipal: true,
+ });
+ var instream = Cc[SIS_CTRID].createInstance(nsISIS);
+ instream.init(chan.open());
+
+ return instream.read(instream.available());
+}
+
+function dump20(aVal) {
+ const pads = " ";
+ if (typeof aVal == "string") {
+ out = aVal;
+ } else if (typeof aVal == "number") {
+ out = Number(aVal).toFixed(2);
+ } else {
+ out = new String(aVal);
+ }
+ dump(pads.substring(0, 20 - out.length));
+ dump(out);
+}
diff --git a/dom/xslt/tests/XSLTMark/XSLTMark-test.js b/dom/xslt/tests/XSLTMark/XSLTMark-test.js
new file mode 100644
index 0000000000..d88a44649a
--- /dev/null
+++ b/dom/xslt/tests/XSLTMark/XSLTMark-test.js
@@ -0,0 +1,41 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+var gParser = new DOMParser();
+var gTimeout;
+
+function Test(aTitle, aSourceURL, aStyleURL, aNumber, aObserver) {
+ this.mTitle = aTitle;
+ this.mObserver = aObserver;
+ this.mTotal = aNumber;
+ this.mDone = 0;
+ var xmlcontent = loadFile(aSourceURL);
+ var xslcontent = loadFile(aStyleURL);
+ this.mSource = gParser.parseFromString(xmlcontent, "application/xml");
+ this.mStyle = gParser.parseFromString(xslcontent, "application/xml");
+}
+
+function runTest(aTitle, aSourceURL, aStyleURL, aNumber, aObserver) {
+ test = new Test(aTitle, aSourceURL, aStyleURL, aNumber, aObserver);
+ gTimeout = setTimeout(onNextTransform, 100, test, 0);
+}
+
+function onNextTransform(aTest, aNumber) {
+ var proc = new XSLTProcessor();
+ var startTime = Date.now();
+ proc.importStylesheet(aTest.mStyle);
+ var res = proc.transformToDocument(aTest.mSource);
+ var endTime = Date.now();
+ aNumber++;
+ var progress = (aNumber / aTest.mTotal) * 100;
+ if (aTest.mObserver) {
+ aTest.mObserver.progress(aTest.mTitle, endTime - startTime, progress);
+ }
+ if (aNumber < aTest.mTotal) {
+ gTimeout = setTimeout(onNextTransform, 100, aTest, aNumber);
+ } else if (aTest.mObserver) {
+ aTest.mObserver.done(aTest.mTitle);
+ }
+}
diff --git a/dom/xslt/tests/XSLTMark/XSLTMark-view.js b/dom/xslt/tests/XSLTMark/XSLTMark-view.js
new file mode 100644
index 0000000000..9436b602a7
--- /dev/null
+++ b/dom/xslt/tests/XSLTMark/XSLTMark-view.js
@@ -0,0 +1,171 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+var view = {
+ configUrl: null,
+ testArray: null,
+ mCurrent: null,
+
+ browseForConfig() {
+ enablePrivilege("UniversalXPConnect");
+ var fp = Cc["@mozilla.org/filepicker;1"].createInstance(nsIFilePicker);
+ fp.init(window, "XSLTMark Description File", nsIFilePicker.modeOpen);
+ fp.appendFilter("*.conf", "*.conf");
+ fp.appendFilters(nsIFilePicker.filterAll);
+ var res = fp.show();
+
+ if (res == nsIFilePicker.returnOK) {
+ this.configUrl = Cc[STDURLMUT_CTRID].createInstance(nsIURIMutator)
+ .setSpec(fp.fileURL.spec)
+ .finalize();
+ document
+ .getElementById("config")
+ .setAttribute("value", this.configUrl.spec);
+ }
+ this.parseConfig();
+ return true;
+ },
+
+ parseConfig() {
+ this.testArray = new Array();
+ var test;
+ if (!this.configUrl) {
+ return;
+ }
+
+ var content = loadFile(this.configUrl.spec);
+
+ var lines = content.split("\n");
+ var line, res;
+ var head = /^\[(.+)\]$/;
+ var instruct = /^(.+)=(.+)$/;
+ while (lines.length) {
+ line = lines.shift();
+ if (head.test(line)) {
+ test = new Object();
+ res = head.exec(line);
+ test.title = res[1];
+ this.testArray.push(test);
+ } else if (line == "") {
+ test = undefined;
+ } else {
+ res = instruct.exec(line);
+ test[res[1]] = res[2];
+ }
+ }
+ },
+
+ onLoad() {
+ this.mCurrentStatus = document.getElementById("currentStatus");
+ this.mCurrentProgress = document.getElementById("currentProgress");
+ this.mTotalProgress = document.getElementById("totalProgress");
+ this.mOutput = document.getElementById("transformOutput");
+ this.mDetailOutput = document.getElementById("transformDetailedOutput");
+ this.mDetail = true;
+ },
+
+ progress(aTitle, aTime, aProgress) {
+ // dump20(aTitle);
+ // dump20(aTime);
+ // dump20(aProgress);
+ this.mCurrentProgress.value = aProgress;
+ this.displayDetailTime(aTime);
+ this.mTimes.push(aTime);
+ // dump("\n");
+ },
+
+ done(aTitle) {
+ // dump(aTitle + " is finished.\n");
+ this.mCurrent++;
+ this.mCurrentProgress.value = 0;
+ this.displayTotalTime();
+ if (this.mCurrent >= this.testArray.length) {
+ this.mTotalProgress.value = 0;
+ this.mCurrentStatus.value = "done";
+ return;
+ }
+ this.mTotalProgress.value = (this.mCurrent * 100) / this.testArray.length;
+ var test = this.testArray[this.mCurrent];
+ enablePrivilege("UniversalXPConnect");
+ this.displayTest(test.title);
+ runTest(
+ test.title,
+ this.configUrl.resolve(test.input),
+ this.configUrl.resolve(test.stylesheet),
+ test.iterations,
+ this
+ );
+ },
+
+ onStop() {
+ clearTimeout(gTimeout);
+ this.mCurrentProgress.value = 0;
+ this.mTotalProgress.value = 0;
+ this.mCurrentStatus.value = "stopped";
+ },
+
+ displayTest(aTitle) {
+ this.mTimes = new Array();
+ aTitle += "\t";
+ this.mCurrentStatus.value = aTitle;
+ this.mOutput.value += aTitle;
+ if (this.mDetail) {
+ this.mDetailOutput.value += aTitle;
+ }
+ },
+
+ displayDetailTime(aTime) {
+ if (this.mDetail) {
+ this.mDetailOutput.value += aTime + " ms\t";
+ }
+ },
+
+ displayTotalTime() {
+ var sum = 0;
+ for (k = 0; k < this.mTimes.length; k++) {
+ sum += this.mTimes[k];
+ }
+ var mean = sum / this.mTimes.length;
+ this.mOutput.value += Number(mean).toFixed(2) + " ms\t" + sum + " ms\t";
+ var variance = 0;
+ for (k = 0; k < this.mTimes.length; k++) {
+ var n = this.mTimes[k] - mean;
+ variance += n * n;
+ }
+ variance = Math.sqrt(variance / this.mTimes.length);
+ this.mOutput.value += Number(variance).toFixed(2) + "\n";
+ if (this.mDetail) {
+ this.mDetailOutput.value += "\n";
+ }
+ },
+
+ runBenchmark() {
+ enablePrivilege("UniversalXPConnect");
+ if (!this.testArray) {
+ if (!this.configUrl) {
+ this.configUrl = Cc[STDURLMUT_CTRID].createInstance(nsIURIMutator)
+ .setSpec(document.getElementById("config").value)
+ .finalize();
+ }
+ this.parseConfig();
+ }
+
+ this.mCurrent = 0;
+ var test = this.testArray[this.mCurrent];
+ this.mOutput.value = "";
+ if (this.mDetail) {
+ this.mDetailOutput.value = "";
+ }
+ this.displayTest(test.title);
+ runTest(
+ test.title,
+ this.configUrl.resolve(test.input),
+ this.configUrl.resolve(test.stylesheet),
+ test.iterations,
+ this
+ );
+ return true;
+ },
+};
diff --git a/dom/xslt/tests/XSLTMark/XSLTMark.css b/dom/xslt/tests/XSLTMark/XSLTMark.css
new file mode 100644
index 0000000000..80386ae2da
--- /dev/null
+++ b/dom/xslt/tests/XSLTMark/XSLTMark.css
@@ -0,0 +1,8 @@
+/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+textbox.out {
+ white-space: pre;
+}
diff --git a/dom/xslt/tests/XSLTMark/XSLTMark.xhtml b/dom/xslt/tests/XSLTMark/XSLTMark.xhtml
new file mode 100644
index 0000000000..0be9a10fb6
--- /dev/null
+++ b/dom/xslt/tests/XSLTMark/XSLTMark.xhtml
@@ -0,0 +1,53 @@
+<?xml version="1.0"?><!-- -*- Mode: xml; tab-width: 2; indent-tabs-mode: nil -*- -->
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+ - License, v. 2.0. If a copy of the MPL was not distributed with this
+ - file, You can obtain one at http://mozilla.org/MPL/2.0/. -->
+
+<?xml-stylesheet href="chrome://global/skin/global.css" type="text/css"?>
+<?xml-stylesheet href="XSLTMark.css" type="text/css"?>
+<window id="XSLTMarkHarness"
+ title="XSLTMark"
+ onload="view.onLoad()"
+ xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+ xmlns:html="http://www.w3.org/1999/xhtml"
+ orient="vertical">
+<script type="application/x-javascript" src="XSLTMark-static.js" />
+<script type="application/x-javascript" src="XSLTMark-test.js" />
+<script type="application/x-javascript" src="XSLTMark-view.js" />
+
+<hbox>
+ <groupbox orient="horizontal">
+ <caption label="test description file" />
+ <label value=""/><!-- needed, otherwise groupbox is broken :-( -->
+ <input xmlns="http://www.w3.org/1999/xhtml" id="config" persist="value" readonly="true"/>
+ <button label="browse..." oncommand="view.browseForConfig();" />
+ </groupbox>
+ <groupbox orient="horizontal">
+ <caption label="test control" />
+ <button label="run..."
+ oncommand="setTimeout('view.runBenchmark();', 0);" />
+ <button label="stop" oncommand="view.onStop();" />
+ </groupbox>
+ <groupbox orient="horizontal">
+ <caption label="options" />
+ <label value="responsiveness: "/>
+ <menulist label="sloppy">
+ <menupopup>
+ <menuitem label="sloppy" selected="true"/>
+ <menuitem label="bad"/>
+ </menupopup>
+ </menulist>
+ </groupbox>
+</hbox>
+<hbox>
+ <input xmlns="http://www.w3.org/1999/xhtml" id="currentStatus" readonly="true" style="-moz-box-flex: 1"/>
+ <progressmeter id="currentProgress" mode="normal" value="0" style="-moz-box-flex: 2"/>
+ <progressmeter id="totalProgress" mode="normal" value="0" style="-moz-box-flex: 2"/>
+</hbox>
+<hbox style="-moz-box-flex: 1">
+ <html:textarea id="transformOutput" class="out" readonly="readonly" style="-moz-box-flex: 1"/>
+</hbox>
+<hbox style="-moz-box-flex: 1">
+ <html:textarea id="transformDetailedOutput" class="out" readonly="readonly" style="-moz-box-flex: 1"/>
+</hbox>
+</window>
diff --git a/dom/xslt/tests/browser/browser.ini b/dom/xslt/tests/browser/browser.ini
new file mode 100644
index 0000000000..63de8e0415
--- /dev/null
+++ b/dom/xslt/tests/browser/browser.ini
@@ -0,0 +1,7 @@
+[DEFAULT]
+
+[browser_bug1309630.js]
+skip-if = true # Bug 1776052
+support-files =
+ bug1309630.sjs
+ file_bug1309630.html
diff --git a/dom/xslt/tests/browser/browser_bug1309630.js b/dom/xslt/tests/browser/browser_bug1309630.js
new file mode 100644
index 0000000000..aee9456abe
--- /dev/null
+++ b/dom/xslt/tests/browser/browser_bug1309630.js
@@ -0,0 +1,74 @@
+"use strict";
+
+const BASE = "https://example.com/browser/dom/xslt/tests/browser";
+const SERVER_SCRIPT = `${BASE}/bug1309630.sjs`;
+
+function resetCounter() {
+ return fetch(`${SERVER_SCRIPT}?reset_counter`);
+}
+function recordCounter() {
+ return fetch(`${SERVER_SCRIPT}?record_counter`);
+}
+// Returns a promise that resolves to true if the counter in
+// bug1309630.sjs changed by more than 'value' since last calling
+// recordCounter(), or false if it doesn't and we time out.
+function waitForCounterChangeAbove(value) {
+ return TestUtils.waitForCondition(() =>
+ fetch(`${SERVER_SCRIPT}?get_counter_change`).then(response =>
+ response.ok
+ ? response.text().then(str => Number(str) > value)
+ : Promise.reject()
+ )
+ ).then(
+ () => true,
+ () => false
+ );
+}
+
+add_task(async function test_eternal_xslt() {
+ await resetCounter();
+ await BrowserTestUtils.withNewTab(
+ { gBrowser, url: SERVER_SCRIPT, waitForLoad: false },
+ async function (browser) {
+ info("Waiting for XSLT to keep loading");
+
+ ok(
+ await waitForCounterChangeAbove(1),
+ "We should receive at least a request from the document function call."
+ );
+
+ info("Navigating to about:blank");
+ BrowserTestUtils.loadURIString(browser, "about:blank");
+ await BrowserTestUtils.browserLoaded(browser);
+
+ info("Check to see if XSLT stops loading");
+ await recordCounter();
+ ok(
+ !(await waitForCounterChangeAbove(0)),
+ "We shouldn't receive more requests to the XSLT file within the timeout period."
+ );
+ }
+ );
+
+ await resetCounter();
+ await BrowserTestUtils.withNewTab(
+ { gBrowser, url: `${BASE}/file_bug1309630.html` },
+ async function (browser) {
+ ok(
+ await waitForCounterChangeAbove(1),
+ "We should receive at least a request from the document function call."
+ );
+
+ info("Navigating to about:blank");
+ BrowserTestUtils.loadURIString(browser, "about:blank");
+ await BrowserTestUtils.browserLoaded(browser);
+
+ info("Check to see if XSLT stops loading");
+ await recordCounter();
+ ok(
+ !(await waitForCounterChangeAbove(0)),
+ "We shouldn't receive more requests to the XSLT file within the timeout period."
+ );
+ }
+ );
+});
diff --git a/dom/xslt/tests/browser/bug1309630.sjs b/dom/xslt/tests/browser/bug1309630.sjs
new file mode 100644
index 0000000000..9a3f464139
--- /dev/null
+++ b/dom/xslt/tests/browser/bug1309630.sjs
@@ -0,0 +1,54 @@
+function handleRequest(request, response) {
+ const XSLT = `<?xml version="1.0"?>
+ <?xml-stylesheet type="text/xsl" href="#bug"?>
+ <xsl:stylesheet id="bug" version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+ <xsl:template name="f" match="/">
+ <xsl:param name="n" select="0" />
+ <xsl:apply-templates select="document(concat('${request.path}?', $n))/xsl:stylesheet/xsl:template[@name='f']">
+ <xsl:with-param name="n" select="$n + 1"/>
+ </xsl:apply-templates>
+ <xsl:call-template name="f">
+ <xsl:with-param name="n" select="$n + 1"/>
+ </xsl:call-template>
+ </xsl:template>
+ </xsl:stylesheet>`;
+
+ // reset_counter sets the counter to -1.
+ if (request.queryString === "reset_counter") {
+ setState("base", "-1");
+ response.write("");
+ return;
+ }
+
+ // record_counter makes us store the current value of the counter.
+ if (request.queryString === "record_counter") {
+ setState("base", getState("counter"));
+ response.write("");
+ return;
+ }
+
+ // get_counter_change returns the difference between the current
+ // value of the counter and the value it had when the script was
+ // loaded with the record_counter query string.
+ if (request.queryString === "get_counter_change") {
+ response.write(
+ String(Number(getState("counter")) - Number(getState("base")))
+ );
+ return;
+ }
+
+ // The XSLT code calls the document() function with a URL pointing to
+ // this script, with the query string set to a counter starting from 0
+ // and incremementing with every call of the document() function.
+ // The first load will happen either from the xml-stylesheet PI, or
+ // with fetch(), to parse a document to pass to
+ // XSLTProcessor.importStylesheet. In that case the query string will
+ // be empty, and we don't change the counter value, we only care about
+ // the loads through the document() function.
+ if (request.queryString) {
+ setState("counter", request.queryString);
+ }
+
+ response.setHeader("Content-Type", "text/xml; charset=utf-8", false);
+ response.write(XSLT);
+}
diff --git a/dom/xslt/tests/browser/file_bug1309630.html b/dom/xslt/tests/browser/file_bug1309630.html
new file mode 100644
index 0000000000..c22889358c
--- /dev/null
+++ b/dom/xslt/tests/browser/file_bug1309630.html
@@ -0,0 +1,19 @@
+<script>
+ let styleDoc = fetch("bug1309630.sjs")
+ .then(response => {
+ if (response.ok) {
+ return response.text();
+ }
+ return Promise.reject();
+ }).then(xslt => {
+ let styleDoc = new DOMParser().parseFromString(xslt, "text/xml");
+ let originalDoc = new DOMParser().parseFromString(
+ "<root/>",
+ "text/xml"
+ );
+
+ let processor = new XSLTProcessor();
+ processor.importStylesheet(styleDoc);
+ processor.transformToDocument(originalDoc);
+ });
+</script>>
diff --git a/dom/xslt/tests/mochitest/bug1729517_2.sjs b/dom/xslt/tests/mochitest/bug1729517_2.sjs
new file mode 100644
index 0000000000..2537a971b0
--- /dev/null
+++ b/dom/xslt/tests/mochitest/bug1729517_2.sjs
@@ -0,0 +1,3 @@
+function handleRequest(request, response) {
+ response.write(request.hasHeader("Referer") ? "FAIL" : "PASS");
+}
diff --git a/dom/xslt/tests/mochitest/file_bug1135764.xml b/dom/xslt/tests/mochitest/file_bug1135764.xml
new file mode 100644
index 0000000000..b9da87e5e5
--- /dev/null
+++ b/dom/xslt/tests/mochitest/file_bug1135764.xml
@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?xml-stylesheet type="text/xsl" href="file_bug1135764.xsl"?>
+<root/>
diff --git a/dom/xslt/tests/mochitest/file_bug1135764.xsl b/dom/xslt/tests/mochitest/file_bug1135764.xsl
new file mode 100644
index 0000000000..e739086cbe
--- /dev/null
+++ b/dom/xslt/tests/mochitest/file_bug1135764.xsl
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+
+<xsl:output method="html"
+ indent="yes"
+ version="5.0"
+ doctype-system="about:legacy-compat"/>
+
+<xsl:template match="/">
+<html>
+<head>
+</head>
+ <body>
+ Some text
+ </body>
+</html>
+</xsl:template>
+
+</xsl:stylesheet>
diff --git a/dom/xslt/tests/mochitest/file_bug1729517.js b/dom/xslt/tests/mochitest/file_bug1729517.js
new file mode 100644
index 0000000000..559a52aa03
--- /dev/null
+++ b/dom/xslt/tests/mochitest/file_bug1729517.js
@@ -0,0 +1,3 @@
+fail(
+ "documents sandboxed without allow-scripts should NOT be able to run <script src=...>"
+);
diff --git a/dom/xslt/tests/mochitest/file_bug1729517.xml b/dom/xslt/tests/mochitest/file_bug1729517.xml
new file mode 100644
index 0000000000..48658468fc
--- /dev/null
+++ b/dom/xslt/tests/mochitest/file_bug1729517.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0"?>
+<?xml-stylesheet type="text/xsl" href="#stylesheet"?>
+<!DOCTYPE root [
+ <!ATTLIST xsl:stylesheet id ID #IMPLIED>
+]>
+<root>
+ <xsl:stylesheet id="stylesheet" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+ <xsl:template match="/">
+ <html>
+ <head>
+ <title>[]</title>
+ <script type="text/javascript">
+ let failed = [];
+ function fail(desc) {
+ failed.push(desc);
+ document.title = JSON.stringify(failed);
+ }
+
+ function doStuff() {
+ fail("documents sandboxed without allow-scripts should NOT be able to run inline scripts");
+ }
+ </script>
+ <script src="file_bug1729517.js" />
+ </head>
+ <body onload="fail('documents sandboxed without allow-scripts should NOT be able to run script from event handlers'); doStuff();">
+ <img src="about:blank" onerror="fail('documents sandboxed without allow-scripts should NOT be able to run script from event handlers');" />
+ </body>
+ </html>
+ </xsl:template>
+</xsl:stylesheet>
+</root>
diff --git a/dom/xslt/tests/mochitest/file_bug1729517_2.xml b/dom/xslt/tests/mochitest/file_bug1729517_2.xml
new file mode 100644
index 0000000000..5d706e7a05
--- /dev/null
+++ b/dom/xslt/tests/mochitest/file_bug1729517_2.xml
@@ -0,0 +1,38 @@
+<?xml version="1.0"?>
+<?xml-stylesheet type="text/xsl" href="#stylesheet"?>
+<!DOCTYPE root [
+ <!ATTLIST xsl:stylesheet id ID #IMPLIED>
+]>
+<root>
+ <xsl:stylesheet id="stylesheet" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+ <xsl:template match="/">
+ <html>
+ <head>
+ <title>[]</title>
+ <script type="text/javascript">
+ async function checkCOEPAndReferrer() {
+ let results = new Map();
+
+ let win = window.open();
+ result = win.fetch("https://example.org/tests/dom/xslt/tests/mochitest/bug1729517_2.sjs", { mode: "no-cors" }).then(() => {
+ return "FAIL";
+ }, () => {
+ return "PASS";
+ });
+ results.set("Cross-Origin-Embedder-Policy", await result);
+ win.close();
+
+ result = fetch("bug1729517_2.sjs").then((response) => {
+ return response.text();
+ });
+ results.set("Referrer-Policy", await result || "FAIL");
+
+ window.opener.postMessage(results, "*");
+ }
+ </script>
+ </head>
+ <body onload="checkCOEPAndReferrer()" />
+ </html>
+ </xsl:template>
+</xsl:stylesheet>
+</root>
diff --git a/dom/xslt/tests/mochitest/file_bug1729517_2.xml^headers^ b/dom/xslt/tests/mochitest/file_bug1729517_2.xml^headers^
new file mode 100644
index 0000000000..6c83b8d686
--- /dev/null
+++ b/dom/xslt/tests/mochitest/file_bug1729517_2.xml^headers^
@@ -0,0 +1,2 @@
+Referrer-Policy: no-referrer
+Cross-Origin-Embedder-Policy: require-corp
diff --git a/dom/xslt/tests/mochitest/file_metaRefresh.xml b/dom/xslt/tests/mochitest/file_metaRefresh.xml
new file mode 100644
index 0000000000..b9e127b8a5
--- /dev/null
+++ b/dom/xslt/tests/mochitest/file_metaRefresh.xml
@@ -0,0 +1,16 @@
+<?xml version="1.0"?>
+<?xml-stylesheet type="text/xsl" href="#stylesheet"?>
+<!DOCTYPE root [
+ <!ATTLIST xsl:stylesheet id ID #IMPLIED>
+]>
+<root>
+ <xsl:stylesheet id="stylesheet" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+ <xsl:template match="/">
+ <html>
+ <head>
+ <meta http-equiv="refresh" content="2"></meta>
+ </head>
+ </html>
+ </xsl:template>
+</xsl:stylesheet>
+</root>
diff --git a/dom/xslt/tests/mochitest/mochitest.ini b/dom/xslt/tests/mochitest/mochitest.ini
new file mode 100644
index 0000000000..385174c335
--- /dev/null
+++ b/dom/xslt/tests/mochitest/mochitest.ini
@@ -0,0 +1,33 @@
+[DEFAULT]
+
+[test_bug1072116.html]
+[test_bug319374.html]
+[test_bug427060.html]
+[test_bug440974.html]
+[test_bug453441.html]
+[test_bug468208.html]
+[test_bug511487.html]
+[test_bug551412.html]
+[test_bug551654.html]
+[test_bug566629.html]
+[test_bug566629.xhtml]
+[test_bug603159.html]
+[test_bug616774.html]
+[test_bug667315.html]
+[test_bug1135764.html]
+support-files = file_bug1135764.xml file_bug1135764.xsl
+[test_bug1436040.html]
+[test_bug1527308.html]
+[test_bug1729517.html]
+support-files =
+ bug1729517_2.sjs
+ file_bug1729517.xml
+ file_bug1729517.js
+ file_bug1729517_2.xml
+ file_bug1729517_2.xml^headers^
+[test_exslt.html]
+[test_metaRefresh.html]
+support-files =
+ file_metaRefresh.xml
+[test_parameter.html]
+[test_sorting_invalid_lang.html]
diff --git a/dom/xslt/tests/mochitest/test_bug1072116.html b/dom/xslt/tests/mochitest/test_bug1072116.html
new file mode 100644
index 0000000000..ec05d23da2
--- /dev/null
+++ b/dom/xslt/tests/mochitest/test_bug1072116.html
@@ -0,0 +1,37 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1072116
+-->
+<head>
+ <title>Test for Bug 1072116</title>
+ <script src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1072116">Mozilla Bug 1072116</a>
+<p id="display"></p>
+<div id="content" style="display: none">
+
+</div>
+<pre id="test">
+<script type="application/javascript">
+
+/** Test for Bug 1072116 **/
+var attr = document.createAttribute("c");
+
+var xpathExpr = document.createExpression('a', null);
+
+var status = false;
+try {
+ xpathExpr.evaluate(attr, null, null, null, null);
+} catch(e) {
+ status = true;
+}
+
+ok(status, "Still alive \\o/");
+
+</script>
+</pre>
+</body>
+</html>
diff --git a/dom/xslt/tests/mochitest/test_bug1135764.html b/dom/xslt/tests/mochitest/test_bug1135764.html
new file mode 100644
index 0000000000..a368b9b4ab
--- /dev/null
+++ b/dom/xslt/tests/mochitest/test_bug1135764.html
@@ -0,0 +1,58 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1135764
+-->
+<head>
+ <meta charset="utf-8">
+ <title>Test for Bug 1135764</title>
+ <script src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+ <script type="application/javascript">
+
+ /** Test for Bug 1135764 **/
+ SimpleTest.waitForExplicitFinish();
+ var counter = 0;
+ var startTimelineValue;
+
+ function waitATick() {
+ ++counter;
+ if (counter == 1) {
+ frames[0].requestAnimationFrame(waitATick);
+ return;
+ }
+ ok(frames[0].document.timeline.currentTime !== startTimelineValue,
+ "The timeline in an XSLT-transformed document should still advance");
+ SimpleTest.finish();
+ }
+ addLoadEvent(function() {
+ SpecialPowers.pushPrefEnv(
+ {
+ set: [
+ ["dom.animations-api.timelines.enabled", true],
+ ],
+ },
+ function() {
+ var ifr = document.querySelector("iframe");
+ ifr.onload = function() {
+ startTimelineValue = frames[0].document.timeline.currentTime;
+ frames[0].requestAnimationFrame(waitATick);
+ };
+ ifr.src = "file_bug1135764.xml";
+ }
+ );
+ });
+ </script>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1135764">Mozilla Bug 1135764</a>
+<p id="display">
+ <iframe></iframe>
+</p>
+<div id="content" style="display: none">
+
+</div>
+<pre id="test">
+</pre>
+</body>
+</html>
diff --git a/dom/xslt/tests/mochitest/test_bug1436040.html b/dom/xslt/tests/mochitest/test_bug1436040.html
new file mode 100644
index 0000000000..df17e75779
--- /dev/null
+++ b/dom/xslt/tests/mochitest/test_bug1436040.html
@@ -0,0 +1,54 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>Test for xslt-param PIs</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<div id="log"></div>
+<script>
+async_test(t => {
+ let iframe = document.createElement('iframe');
+ let src = `<?xml version="1.0"?>
+ <?xslt-param name="param" value="true"?>
+ <?xml-stylesheet type="text/xml" href="#bug"?>
+ <doc>
+ <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0" id="bug">
+ <xsl:output method="html"/>
+ <xsl:param name="param">false</xsl:param>
+ <xsl:template match="/">
+ <xsl:element name="script">parent.postMessage({test: 1, result: <xsl:value-of select="$param"/>}, "*");</xsl:element>
+ </xsl:template>
+ </xsl:stylesheet>
+ </doc>`;
+ iframe.src = "data:text/xml," + encodeURIComponent(src);
+ self.addEventListener("message", t.step_func_done(({data: {test, result}}) => {
+ if (test == 1) {
+ assert_true(result, "The stylesheet param's value should be set by the xslt-param PI.");
+ }
+ }));
+ document.body.appendChild(iframe);
+}, "Test for xslt-param PIs");
+async_test(t => {
+ let iframe = document.createElement('iframe');
+ let src = `<?xml version="1.0"?>
+ <?xslt-param-namespace prefix="foo" namespace="foonamespace"?>
+ <?xslt-param name="param" select="//foo:default"?>
+ <?xml-stylesheet type="text/xml" href="#bug"?>
+ <doc>
+ <default xmlns="foonamespace">true</default>
+ <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0" id="bug">
+ <xsl:output method="html"/>
+ <xsl:param name="param">false</xsl:param>
+ <xsl:template match="/">
+ <xsl:element name="script">parent.postMessage({test: 2, result: <xsl:value-of select="$param"/>}, "*");</xsl:element>
+ </xsl:template>
+ </xsl:stylesheet>
+ </doc>`;
+ iframe.src = "data:text/xml," + encodeURIComponent(src);
+ self.addEventListener("message", t.step_func_done(({data: {test, result}}) => {
+ if (test == 2) {
+ assert_true(result, "xslt-param-namespace should have set the right namespace");
+ }
+ }));
+ document.body.appendChild(iframe);
+}, "Test for xslt-param PIs");
+</script>
diff --git a/dom/xslt/tests/mochitest/test_bug1527308.html b/dom/xslt/tests/mochitest/test_bug1527308.html
new file mode 100644
index 0000000000..c37a0c1f00
--- /dev/null
+++ b/dom/xslt/tests/mochitest/test_bug1527308.html
@@ -0,0 +1,38 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>Test for serialized state in XSLT result document</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<div id="log"></div>
+<script>
+async_test(t => {
+ let iframe = document.createElement('iframe');
+ let src = `<?xml version="1.0"?>
+ <?xml-stylesheet type="text/xml" href="#stylesheet"?>
+ <doc>
+ <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0" id="stylesheet">
+ <xsl:output method="html"/>
+ <xsl:template match="/">
+ <html>
+ <xsl:element name="script">self.addEventListener("message", () => { history.go(0); });</xsl:element>
+ <body onload="parent.postMessage(history.state, '*'); history.replaceState('data', 'title');"></body>
+ </html>
+ </xsl:template>
+ </xsl:stylesheet>
+ </doc>`;
+ iframe.src = "data:text/xml," + encodeURIComponent(src);
+ let reloaded = false;
+ self.addEventListener("message", t.step_func(({data: state}) => {
+ if (!reloaded) {
+ assert_equals(state, null, "At this point history.state should be set.");
+ iframe.contentWindow.postMessage("", "*");
+ reloaded = true;
+ return;
+ }
+
+ assert_equals(state, 'data', "Data set through history.replaceState in an XSLT result document should persist.");
+ t.done();
+ }));
+ document.body.appendChild(iframe);
+}, "Test for serialized state in XSLT result document");
+</script>
diff --git a/dom/xslt/tests/mochitest/test_bug1729517.html b/dom/xslt/tests/mochitest/test_bug1729517.html
new file mode 100644
index 0000000000..062d832d98
--- /dev/null
+++ b/dom/xslt/tests/mochitest/test_bug1729517.html
@@ -0,0 +1,48 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+ <meta charset="utf-8">
+ <title><!-- TODO: insert title here --></title>
+ <script src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" href="/tests/SimpleTest/test.css"/>
+ <script>
+ SimpleTest.waitForExplicitFinish();
+ async function runTest() {
+ let frame = document.getElementById("frame");
+ let loaded = new Promise((resolve) => {
+ frame.addEventListener("load", () => {
+ let failed = JSON.parse(frame.contentDocument.title);
+ ok(failed instanceof Array, "Frame's title is expected to be a JSON representation of the array of failed conditions.");
+ is(failed.length, 0, "No scripts should run in sandboxed iframe document created by XSLT.");
+ for (desc of failed) {
+ info(desc);
+ }
+ resolve();
+ }, { once: true });
+ });
+ frame.src = "file_bug1729517.xml";
+ await loaded;
+
+ let results = new Promise((resolve) => {
+ addEventListener("message", ({ data }) => {
+ resolve(data);
+ }, { once: true });
+ });
+
+ let win = window.open(`https://example.com/tests/dom/xslt/tests/mochitest/file_bug1729517_2.xml`);
+ for (const [header, result] of await results) {
+ is(result, "PASS", `${header} of the source document should apply to document created by XSLT.`);
+ }
+ win.close();
+
+ SimpleTest.finish();
+ }
+ </script>
+</head>
+<body onload="runTest();">
+<p id="display"></p>
+<iframe sandbox="allow-same-origin" id="frame"></iframe>
+<div id="content" style="display: none"></div>
+<pre id="test"></pre>
+</body>
+</html>
diff --git a/dom/xslt/tests/mochitest/test_bug319374.html b/dom/xslt/tests/mochitest/test_bug319374.html
new file mode 100644
index 0000000000..92d48e037a
--- /dev/null
+++ b/dom/xslt/tests/mochitest/test_bug319374.html
@@ -0,0 +1,101 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=319374
+-->
+<head>
+ <title>Test for Bug 319374</title>
+ <script src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=319374">Mozilla Bug 319374</a>
+<p id="display"></p>
+<div id="content"><custom-el></custom-el><custom-el></custom-el><custom-el></custom-el></div>
+<pre id="test">
+<script class="testbody" type="text/javascript">
+
+customElements.define("custom-el", class extends HTMLElement {
+ constructor() {
+ super();
+ this.attachShadow({ mode: "open" });
+ this.shadowRoot.innerHTML =
+ `<span attr="attribute"><span></span></span><span> anon text </span><br>`;
+ }
+});
+
+ function testChangesInShadowDOM() {
+ // Test 1: Make sure that modifying anonymous content doesn't
+ // cause non-anonymous XPath result to throw exceptions..
+ var counter = 0;
+ var error = null;
+ try {
+ var xp = new XPathEvaluator();
+ var result = xp.evaluate("*",
+ document.getElementById('content'),
+ null,
+ XPathResult.UNORDERED_NODE_ITERATOR_TYPE,
+ null);
+ var res = null;
+ while (res = result.iterateNext()) {
+ ++counter;
+ let anon = res.shadowRoot.childNodes;
+ anon[0].firstChild.remove(); // Removing a child node
+ anon[0].removeAttribute("attr1"); // Removing an attribute
+ anon[1].firstChild.data = "anon text changed" // Modifying text data
+ }
+ } catch (e) {
+ error = e;
+ }
+ ok(!error, error);
+ ok(counter == 3, "XPathEvaluator should have found 3 elements.")
+
+ // Test 2: If the context node is in anonymous content, changing some
+ // other anonymous tree shouldn't cause XPath result to throw.
+ let shadowAttr1 = document.getElementById("content").firstChild.
+ shadowRoot.firstChild.getAttributeNode("attr");
+ let shadowAttr2 = document.getElementById("content").lastChild.
+ shadowRoot.firstChild.getAttributeNode("attr");
+ var resultAttr = null;
+ try {
+ var xp2 = xp.evaluate(".",
+ shadowAttr1,
+ null,
+ XPathResult.UNORDERED_NODE_ITERATOR_TYPE,
+ null);
+ // Attribute changing in a different anonymous tree.
+ shadowAttr2.value = "foo";
+ resultAttr = xp2.iterateNext();
+ is(resultAttr, shadowAttr1, "XPathEvaluator returned wrong attribute!");
+ } catch (e) {
+ ok(false, e);
+ }
+
+ // Test 3: If the anonymous tree in which context node is in is modified,
+ // XPath result should throw when iterateNext() is called.
+ resultAttr = null;
+ try {
+ var xp3 = xp.evaluate(".",
+ shadowAttr1,
+ null,
+ XPathResult.UNORDERED_NODE_ITERATOR_TYPE,
+ null);
+ // Attribute changing in the same anonymous tree.
+ shadowAttr1.ownerElement.setAttribute("foo", "bar");
+ resultAttr = xp3.iterateNext();
+ ok(resultAttr == shadowAttr1,
+ "XPathEvaluator should have thrown an exception!")
+ } catch (e) {
+ ok(true, e);
+ }
+
+ SimpleTest.finish();
+ }
+
+ SimpleTest.waitForExplicitFinish();
+ addLoadEvent(testChangesInShadowDOM);
+</script>
+</pre>
+</body>
+</html>
+
diff --git a/dom/xslt/tests/mochitest/test_bug427060.html b/dom/xslt/tests/mochitest/test_bug427060.html
new file mode 100644
index 0000000000..0dac88b74b
--- /dev/null
+++ b/dom/xslt/tests/mochitest/test_bug427060.html
@@ -0,0 +1,49 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=427060
+-->
+<head>
+ <title>Test for Bug 427060</title>
+ <script src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=427060">Mozilla Bug 427060</a>
+<p id="display"></p>
+<div id="content" style="display: none">
+
+</div>
+<pre id="test">
+<script class="testbody" type="text/javascript">
+
+/** Test for Bug 427060 **/
+
+var xmldoc, xsltdoc;
+
+xmldoc = new DOMParser().parseFromString('<opml version="1.0"><body></body></opml>', "text/xml");
+xsltdoc = new DOMParser().parseFromString('<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">\n\
+ <xsl:template match="/opml">\n\
+ <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">\n\
+ <head>\n\
+ <base target="_blank"></base>\n\
+ </head>\n\
+ <body></body>\n\
+ </html>\n\
+ </xsl:template>\n\
+ </xsl:stylesheet>', "text/xml");
+
+var processor = new XSLTProcessor;
+processor.importStylesheet(xsltdoc);
+try
+{
+ var result = processor.transformToDocument(xmldoc);
+}
+catch (e)
+{
+}
+ok(result && result instanceof Document, "XSLT transform should have created a document");
+</script>
+</pre>
+</body>
+</html>
diff --git a/dom/xslt/tests/mochitest/test_bug440974.html b/dom/xslt/tests/mochitest/test_bug440974.html
new file mode 100644
index 0000000000..40745ae210
--- /dev/null
+++ b/dom/xslt/tests/mochitest/test_bug440974.html
@@ -0,0 +1,46 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=440974
+-->
+<head>
+ <title>Test for Bug 440974</title>
+ <script src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=440974">Mozilla Bug 440974</a>
+<p id="display"></p>
+<div id="content" style="display: none">
+
+</div>
+<pre id="test">
+<script class="testbody" type="text/javascript">
+
+/** Test for Bug 440974 **/
+
+function isTxResult(node)
+{
+ return node.namespaceURI == "http://www.mozilla.org/TransforMiix" &&
+ node.localName == "result";
+}
+
+var xmldoc, xsltdoc;
+
+xmldoc = new DOMParser().parseFromString('<items><item><id>1</id></item><item><id>2</id></item><item><id>3</id></item></items>', "text/xml");
+xsltdoc = new DOMParser().parseFromString('<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">\n\
+ <xsl:output method="xml" />\n\
+ <xsl:template match="item"><foo id="{id}"/></xsl:template>\n\
+ </xsl:stylesheet>', "text/xml");
+
+var processor = new XSLTProcessor;
+processor.importStylesheet(xsltdoc);
+var result = processor.transformToDocument(xmldoc);
+var resultElements = Array.prototype.filter.call(result.getElementsByTagName('*'), isTxResult);
+is(resultElements.length, 1, "there should be only one 'transformiix:result' element");
+is(resultElements[0], result.documentElement, "the 'transformiix:result' element should be the document element");
+
+</script>
+</pre>
+</body>
+</html>
diff --git a/dom/xslt/tests/mochitest/test_bug453441.html b/dom/xslt/tests/mochitest/test_bug453441.html
new file mode 100644
index 0000000000..1d8b554c00
--- /dev/null
+++ b/dom/xslt/tests/mochitest/test_bug453441.html
@@ -0,0 +1,57 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=453441
+-->
+<head>
+ <title>Test for Bug 453441</title>
+ <script src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=453441">Mozilla Bug 453441</a>
+<p id="display"></p>
+<div id="content" style="display: none">
+
+</div>
+<pre id="test">
+<script class="testbody" type="text/javascript">
+
+/** Test for Bug 453441 **/
+
+function tryImportStylesheet(xml, valid)
+{
+ var processor = new XSLTProcessor;
+
+ var xsltdoc = new DOMParser().parseFromString(xml, "text/xml");
+ try
+ {
+ processor.importStylesheet(xsltdoc);
+ ok(valid, "should be able to parse this XSLT stylesheet");
+ }
+ catch (e)
+ {
+ ok(!valid, "should not be able to parse this XSLT stylesheet");
+ }
+}
+
+tryImportStylesheet(
+ '<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">\n\
+ <xsl:template match="/">\n\
+ <html xmlns="http://www.w3.org/1999/xhtml" xsl:version="1.0" />\n\
+ </xsl:template>\n\
+ </xsl:stylesheet>'
+, true);
+
+tryImportStylesheet(
+ '<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" />'
+, false);
+
+tryImportStylesheet(
+ '<xsl:transform xmlns:xsl="http://www.w3.org/1999/XSL/Transform" />'
+, false);
+
+</script>
+</pre>
+</body>
+</html>
diff --git a/dom/xslt/tests/mochitest/test_bug468208.html b/dom/xslt/tests/mochitest/test_bug468208.html
new file mode 100644
index 0000000000..d3c05c7374
--- /dev/null
+++ b/dom/xslt/tests/mochitest/test_bug468208.html
@@ -0,0 +1,35 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=468208
+-->
+<head>
+ <title>Test for Bug 468208</title>
+ <script src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=468208">Mozilla Bug 468208</a>
+<p id="display"></p>
+<div id="content" style="display: none">
+
+</div>
+<pre id="test">
+<script class="testbody" type="text/javascript">
+
+/** Test for Bug 468208 **/
+var xslt =
+ '<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">\n\
+ <xsl:strip-space elements="color"/>\n\
+ </xsl:stylesheet>'
+;
+var xsltdoc = new DOMParser().parseFromString(xslt, "text/xml");
+
+var processor = new XSLTProcessor;
+processor.importStylesheet(xsltdoc);
+ok(true, "XSLT shouldn't leak");
+</script>
+</pre>
+</body>
+</html>
diff --git a/dom/xslt/tests/mochitest/test_bug511487.html b/dom/xslt/tests/mochitest/test_bug511487.html
new file mode 100644
index 0000000000..324ba04679
--- /dev/null
+++ b/dom/xslt/tests/mochitest/test_bug511487.html
@@ -0,0 +1,59 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=511487
+-->
+<head>
+ <title>Test for Bug 511487</title>
+ <script src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=511487">Mozilla Bug 511487</a>
+<p id="display"></p>
+<div id="content" style="display: none">
+
+</div>
+<pre id="test">
+<script type="application/javascript">
+
+/** Test for Bug 511487 **/
+
+ var didTransform = false;
+ var processor = new XSLTProcessor();
+ var style =
+ '<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0" xmlns="http://www.w3.org/1999/xhtml">' +
+ '<xsl:output method="xml" version="1.0" encoding="UTF-8" doctype-system="http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd" doctype-public="-//W3C//DTD XHTML 1.0 Transitional//EN" />' +
+ '<xsl:template match="wml">' +
+ '<html xmlns="http://www.w3.org/1999/xhtml">' +
+ '<head>' +
+ '<title>XSLT test</title>' +
+ '</head>' +
+ '<body onload="window.alert(this)">' +
+ '</body>' +
+ '</html>' +
+ '</xsl:template>' +
+ '</xsl:stylesheet>';
+ var styleDoc = new DOMParser().parseFromString (style, "text/xml");
+
+ var data =
+ '<?xml version="1.0"?>' +
+ '<!DOCTYPE wml PUBLIC "-//WAPFORUM//DTD WML 1.1//EN" "http://www.wapforum.org/DTD/wml_1.1.xml">' +
+ '<wml><card><p>paragraph</p></card></wml>';
+ var originalDoc = new DOMParser().parseFromString(data, "text/xml");
+
+ processor.importStylesheet(styleDoc);
+ try {
+ var transformedDocument = processor.transformToDocument(originalDoc);
+ didTransform = true;
+ } catch (e) {
+ ok(false, e);
+ }
+
+ ok(didTransform, "transformToDocument didn't succeed!");
+
+
+</script>
+</pre>
+</body>
+</html>
diff --git a/dom/xslt/tests/mochitest/test_bug551412.html b/dom/xslt/tests/mochitest/test_bug551412.html
new file mode 100644
index 0000000000..399310a014
--- /dev/null
+++ b/dom/xslt/tests/mochitest/test_bug551412.html
@@ -0,0 +1,48 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=551412
+-->
+<head>
+ <title>Test for Bug 551412</title>
+ <script src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=551412">Mozilla Bug 551412</a>
+<p id="display"></p>
+<div id="content" style="display: none"></div>
+<pre id="test">
+<script type="application/javascript">
+
+/** Test for Bug 551412 **/
+
+ var processor = new XSLTProcessor();
+ var style =
+ '<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" ' +
+ 'xmlns:exsl="http://exslt.org/common" ' +
+ 'version="1.0">' +
+ '<xsl:output method="html"/>' +
+ '<xsl:variable name="rtf">1 <b>2</b> 3</xsl:variable>' +
+ '<xsl:template match="/">' +
+ '<xsl:copy-of select="exsl:node-set($rtf)"/>' +
+ '</xsl:template>' +
+ '</xsl:stylesheet>';
+ var styleDoc = new DOMParser().parseFromString (style, "text/xml");
+
+ var data =
+ '<root/>';
+ var originalDoc = new DOMParser().parseFromString(data, "text/xml");
+
+ processor.importStylesheet(styleDoc);
+
+ var fragment = processor.transformToFragment(originalDoc, document);
+ var content = document.getElementById("content");
+ content.appendChild(fragment);
+ is(content.innerHTML, "1 <b>2</b> 3",
+ "Result of transform should be '1 <b>2</b> 3'");
+
+</script>
+</pre>
+</body>
+</html>
diff --git a/dom/xslt/tests/mochitest/test_bug551654.html b/dom/xslt/tests/mochitest/test_bug551654.html
new file mode 100644
index 0000000000..0bdd2dda60
--- /dev/null
+++ b/dom/xslt/tests/mochitest/test_bug551654.html
@@ -0,0 +1,49 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=551654
+-->
+<head>
+ <title>Test for Bug 551654</title>
+ <script src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=551654">Mozilla Bug 551654</a>
+<p id="display"></p>
+<div id="content" style="display: none">
+
+</div>
+<pre id="test">
+<script type="application/javascript">
+
+/** Test for Bug 551654 **/
+
+ var didTransform = false;
+ var processor = new XSLTProcessor();
+ var style =
+ '<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" ' +
+ 'xmlns:exsl="http://exslt.org/common" ' +
+ 'version="1.0">' +
+ '<xsl:output method="html"/>' +
+ '<xsl:template match="/">' +
+ '<xsl:copy-of select="exsl:node-set(42)"/>' +
+ '</xsl:template>' +
+ '</xsl:stylesheet>';
+ var styleDoc = new DOMParser().parseFromString (style, "text/xml");
+
+ var data =
+ '<root/>';
+ var originalDoc = new DOMParser().parseFromString(data, "text/xml");
+
+ processor.importStylesheet(styleDoc);
+ var fragment = processor.transformToFragment(originalDoc, document);
+ is(fragment.firstChild.nodeType, Node.TEXT_NODE,
+ "Result of transform should be a textnode");
+ is(fragment.firstChild.nodeValue, "42",
+ "Result of transform should be a textnode with value '42'");
+
+</script>
+</pre>
+</body>
+</html>
diff --git a/dom/xslt/tests/mochitest/test_bug566629.html b/dom/xslt/tests/mochitest/test_bug566629.html
new file mode 100644
index 0000000000..5670207145
--- /dev/null
+++ b/dom/xslt/tests/mochitest/test_bug566629.html
@@ -0,0 +1,70 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=566629
+-->
+<head>
+ <title>Test for Bug 566629</title>
+ <script src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=566629">Mozilla Bug 566629</a>
+<p id="display"></p>
+<div id="content" style="display: none">
+
+</div>
+<pre id="test">
+<script class="testbody" type="text/javascript">
+
+/** Test for Bug 566629 **/
+
+var xsltdoc = new DOMParser().parseFromString(
+ '<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"\
+ xmlns:xhtml="http://www.w3.org/1999/xhtml">\
+ <xsl:template match="/">\
+ <xsl:value-of select="count(//body)"/>\
+ <xsl:text>,</xsl:text>\
+ <xsl:value-of select="count(//xhtml:body)"/>\
+ <xsl:text>,</xsl:text>\
+ <xsl:value-of select="count(//xsl:body)"/>\
+ <xsl:text>,</xsl:text>\
+ <xsl:value-of select="name(//body)"/>\
+ <xsl:text>,</xsl:text>\
+ <xsl:value-of select="local-name(//body)"/>\
+ </xsl:template>\
+ </xsl:stylesheet>',
+ "text/xml");
+
+var processor = new XSLTProcessor;
+processor.importStylesheet(xsltdoc);
+var result = processor.transformToFragment(document, document);
+ok(result instanceof DocumentFragment, "returned a docfragment");
+is(result.firstChild.nodeValue, "1,1,0,BODY,body",
+ "correct treatment of HTML elements in XSLT");
+
+is(document.evaluate("count(//body)", document, null, XPathResult.ANY_TYPE, null).numberValue,
+ 1, "namespace-less node-test");
+is(document.evaluate("count(//a:body)", document,
+ function() { return "http://www.w3.org/1999/xhtml" },
+ XPathResult.ANY_TYPE, null).numberValue,
+ 1, "with-namespace node-test");
+is(document.evaluate("count(//a:body)", document,
+ function() { return "foo" },
+ XPathResult.ANY_TYPE, null).numberValue,
+ 0, "wrong-namespace node-test");
+is(document.evaluate("//bODy", document, null, XPathResult.ANY_TYPE, null).iterateNext(),
+ document.body, "case insensitive matching");
+is(document.evaluate("count(//a:bODy)", document,
+ function() { return "http://www.w3.org/1999/xhtml" },
+ XPathResult.ANY_TYPE, null).numberValue,
+ 0, "with-namespace but wrong casing node-test");
+is(document.evaluate("name(//body)", document, null, XPathResult.ANY_TYPE, null).stringValue,
+ "BODY", "uppercase name() function");
+is(document.evaluate("local-name(//body)", document, null, XPathResult.ANY_TYPE, null).stringValue,
+ "body", "lowercase local-name() function");
+
+</script>
+</pre>
+</body>
+</html>
diff --git a/dom/xslt/tests/mochitest/test_bug566629.xhtml b/dom/xslt/tests/mochitest/test_bug566629.xhtml
new file mode 100644
index 0000000000..0880a36002
--- /dev/null
+++ b/dom/xslt/tests/mochitest/test_bug566629.xhtml
@@ -0,0 +1,73 @@
+<html xmlns="http://www.w3.org/1999/xhtml">
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=566629
+-->
+<head>
+ <title>Test for Bug 566629</title>
+ <script src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=566629">Mozilla Bug 566629</a>
+<p id="display"></p>
+<div id="content" style="display: none">
+
+</div>
+<pre id="test">
+<script class="testbody" type="text/javascript">
+<![CDATA[
+/** Test for Bug 566629 **/
+
+var xsltdoc = new DOMParser().parseFromString(
+ '<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"\
+ xmlns:xhtml="http://www.w3.org/1999/xhtml">\
+ <xsl:template match="/">\
+ <xsl:value-of select="count(//body)"/>\
+ <xsl:text>,</xsl:text>\
+ <xsl:value-of select="count(//xhtml:body)"/>\
+ <xsl:text>,</xsl:text>\
+ <xsl:value-of select="count(//xsl:body)"/>\
+ <xsl:text>,</xsl:text>\
+ <xsl:value-of select="name(//xhtml:body)"/>\
+ <xsl:text>,</xsl:text>\
+ <xsl:value-of select="local-name(//xhtml:body)"/>\
+ </xsl:template>\
+ </xsl:stylesheet>',
+ "text/xml");
+
+var processor = new XSLTProcessor;
+processor.importStylesheet(xsltdoc);
+var result = processor.transformToFragment(document, document);
+ok(result instanceof DocumentFragment, "returned a docfragment");
+is(result.firstChild.nodeValue, "0,1,0,body,body",
+ "correct treatment of HTML elements in XSLT");
+
+is(document.evaluate("count(//body)", document, null, XPathResult.ANY_TYPE, null).numberValue,
+ 0, "namespace-less node-test");
+is(document.evaluate("count(//a:body)", document,
+ function() { return "http://www.w3.org/1999/xhtml" },
+ XPathResult.ANY_TYPE, null).numberValue,
+ 1, "with-namespace node-test");
+is(document.evaluate("count(//a:body)", document,
+ function() { return "foo" },
+ XPathResult.ANY_TYPE, null).numberValue,
+ 0, "wrong-namespace node-test");
+is(document.evaluate("count(//a:bODy)", document,
+ function() { return "http://www.w3.org/1999/xhtml" },
+ XPathResult.ANY_TYPE, null).numberValue,
+ 0, "with-namespace wrong-casing node-test");
+is(document.evaluate("count(//bODy)", document, null, XPathResult.ANY_TYPE, null).numberValue,
+ 0, "without-namespace wrong-casing node-test");
+is(document.evaluate("name(//a:body)", document,
+ function() { return "http://www.w3.org/1999/xhtml" },
+ XPathResult.ANY_TYPE, null).stringValue,
+ "body", "name()");
+is(document.evaluate("local-name(//a:body)", document,
+ function() { return "http://www.w3.org/1999/xhtml" },
+ XPathResult.ANY_TYPE, null).stringValue,
+ "body", "local-name()");
+]]>
+</script>
+</pre>
+</body>
+</html>
diff --git a/dom/xslt/tests/mochitest/test_bug603159.html b/dom/xslt/tests/mochitest/test_bug603159.html
new file mode 100644
index 0000000000..95c4efa9c5
--- /dev/null
+++ b/dom/xslt/tests/mochitest/test_bug603159.html
@@ -0,0 +1,54 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=603159
+-->
+<head>
+ <title>Test for Bug 603159</title>
+ <script src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=603159">Mozilla Bug 603159</a>
+<p id="display"></p>
+<div id="content" style="display: none"></div>
+<pre id="test">
+<script type="application/javascript">
+
+/** Test for Bug 603159 **/
+
+ var style =
+ '<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" ' +
+ 'xmlns:date="http://exslt.org/dates-and-times" '+
+ 'version="1.0">' +
+ '<xsl:output method="html"/>' +
+ '<xsl:template match="/">' +
+ '<xsl:value-of select="date:date-time()" /> ' +
+ '</xsl:template>' +
+ '</xsl:stylesheet>';
+ var styleDoc = new DOMParser().parseFromString (style, "text/xml");
+
+ var data = '<root/>';
+ var originalDoc = new DOMParser().parseFromString(data, "text/xml");
+
+ var processor = new XSLTProcessor();
+ processor.importStylesheet(styleDoc);
+
+ var fragment = processor.transformToFragment(originalDoc, document);
+ var content = document.getElementById("content");
+ content.appendChild(fragment);
+
+ // use Gecko's Date.parse to parse, then compare the milliseconds since epoch
+ var xslt_ms = Date.parse(content.innerHTML);
+ var now_ms = new Date().getTime();
+ var accepted_diff = 30 * 60 * 1000; // 30 minutes
+ var diff = Math.abs(now_ms - xslt_ms);
+
+ ok(diff < accepted_diff, "generated timestamp should be not more than "
+ + accepted_diff + " ms before 'now', but the difference was: " + diff);
+
+ content.innerHTML = '';
+</script>
+</pre>
+</body>
+</html>
diff --git a/dom/xslt/tests/mochitest/test_bug616774.html b/dom/xslt/tests/mochitest/test_bug616774.html
new file mode 100644
index 0000000000..e970b778e9
--- /dev/null
+++ b/dom/xslt/tests/mochitest/test_bug616774.html
@@ -0,0 +1,28 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=616774-->
+<head>
+ <title>Test for Bug 616774</title>
+ <script type="text/javascript" src="/MochiKit/MochiKit.js"></script>
+ <script src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=616774">Mozilla Bug 616774</a>
+<p id="display"></p>
+<div id="content" style="display: none">
+ 42
+</div>
+<pre id="test">
+<script class="testbody" type="text/javascript">
+
+/** Test for Bug 616774 **/
+is(document.evaluate('- "8"', document, null, XPathResult.ANY_TYPE, null).numberValue, -8, "Negated string literal should evaluate to itself negated");
+is(document.evaluate('- - "999"', document, null, XPathResult.ANY_TYPE, null).numberValue, 999, "String literal should evaluate to itself");
+is(document.evaluate('- - id("content")', document, null, XPathResult.ANY_TYPE, null).numberValue, 42, "DOM element should evaluate to itself coerced to a number");
+
+</script>
+</pre>
+</body>
+</html>
diff --git a/dom/xslt/tests/mochitest/test_bug667315.html b/dom/xslt/tests/mochitest/test_bug667315.html
new file mode 100644
index 0000000000..a54fa05f42
--- /dev/null
+++ b/dom/xslt/tests/mochitest/test_bug667315.html
@@ -0,0 +1,46 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=667315
+-->
+<head>
+ <title>Test for Bug 667315</title>
+ <script src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=667315">Mozilla Bug 667315</a>
+<p id="display"></p>
+<div id="content" style="display: none">
+
+</div>
+<pre id="test">
+<script type="application/javascript">
+
+/** Test for Bug 667315 **/
+
+var style =
+ '<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" ' +
+ 'version="1.0">' +
+ '<xsl:variable name="var">' +
+ '<html><p>a</p></html>' +
+ '</xsl:variable>' +
+ '<xsl:template match="/">' +
+ '<xsl:copy-of select="$var" />' +
+ '</xsl:template>' +
+ '</xsl:stylesheet>';
+var styleDoc = new DOMParser().parseFromString (style, "text/xml");
+
+var data = '<root/>';
+var originalDoc = new DOMParser().parseFromString(data, "text/xml");
+
+var processor = new XSLTProcessor();
+processor.importStylesheet(styleDoc);
+
+var doc = processor.transformToDocument(originalDoc);
+ok(doc instanceof HTMLDocument, "should have switched to html output method");
+
+</script>
+</pre>
+</body>
+</html>
diff --git a/dom/xslt/tests/mochitest/test_exslt.html b/dom/xslt/tests/mochitest/test_exslt.html
new file mode 100644
index 0000000000..739d1c1988
--- /dev/null
+++ b/dom/xslt/tests/mochitest/test_exslt.html
@@ -0,0 +1,249 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+Test EXSLT extensions
+http://www.exslt.org/
+-->
+<head>
+ <title>Test for EXSLT extensions</title>
+ <script src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<p id="display"></p>
+<div id="content" style="display: none"></div>
+<pre id="test">
+<script type="application/javascript">
+ let tests = [
+ {
+ descr: "Testing common:node-set",
+ expr: "common:node-set($tree)",
+ useCopyOf: true,
+ expResult: "<abc>def</abc>",
+ },
+ {
+ descr: "Testing common:object-type(string)",
+ expr: "common:object-type($string)",
+ expResult: "string",
+ },
+ {
+ descr: "Testing common:object-type(number)",
+ expr: "common:object-type($number)",
+ expResult: "number",
+ },
+ {
+ descr: "Testing common:object-type(boolean)",
+ expr: "common:object-type($boolean)",
+ expResult: "boolean",
+ },
+ {
+ descr: "Testing common:object-type(node-set)",
+ expr: "common:object-type($node-set)",
+ expResult: "node-set",
+ },
+ {
+ descr: "Testing common:object-type(tree)",
+ expr: "common:object-type($tree)",
+ expResult: "RTF",
+ },
+ {
+ descr: "Testing math:max",
+ expr: "math:max(root/numbers/number)",
+ expResult: "11",
+ },
+ {
+ descr: "Testing math:min",
+ expr: "math:min(root/numbers/number)",
+ expResult: "4",
+ },
+ {
+ descr: "Testing math:highest",
+ expr: "math:highest(root/numbers/number)/@id",
+ expResult: "eleven",
+ },
+ {
+ descr: "Testing math:lowest",
+ expr: "math:lowest(root/numbers/number)/@id",
+ expResult: "four",
+ },
+ {
+ descr: "Testing regexp:test",
+ expr: "regexp:test('XSLT is great', 'XSLT', '')",
+ expResult: "true",
+ },
+ {
+ descr: "Testing regexp:match",
+ expr: "regexp:match('XSLT is great', 'XSL.', '')[1]",
+ expResult: "XSLT",
+ },
+ {
+ descr: "Testing regexp:replace",
+ expr: "regexp:replace('Food is great', 'Fo.d', '', 'XSLT')",
+ expResult: "XSLT is great",
+ },
+ {
+ descr: "Testing sets:difference",
+ expr: "sets:difference($i, $e)",
+ useCopyOf: true,
+ expResult: "<city name=\"Paris\" country=\"France\"></city><city name=\"Madrid\" country=\"Spain\"></city><city name=\"Calais\" country=\"France\"></city>",
+ },
+ {
+ descr: "Testing sets:distinct",
+ expr: "strings:concat(sets:distinct(//@country))",
+ expResult: "FranceSpainAustriaGermany",
+ },
+ {
+ descr: "Testing sets:hasSameNode",
+ expr: "sets:has-same-node($i, $e)",
+ expResult: "true",
+ },
+ {
+ descr: "Testing sets:hasSameNode",
+ expr: "sets:has-same-node($i, $o)",
+ expResult: "false",
+ },
+ {
+ descr: "Testing sets:intersection",
+ expr: "sets:intersection($i, $e)",
+ useCopyOf: true,
+ expResult: "<city name=\"Vienna\" country=\"Austria\"></city><city name=\"Berlin\" country=\"Germany\"></city>",
+ },
+ {
+ descr: "Testing sets:leading",
+ expr: "sets:leading($i, $e)",
+ useCopyOf: true,
+ expResult: "<city name=\"Paris\" country=\"France\"></city><city name=\"Madrid\" country=\"Spain\"></city>",
+ },
+ {
+ descr: "Testing sets:leading",
+ expr: "sets:leading($i, $o)",
+ useCopyOf: true,
+ expResult: "",
+ },
+ {
+ descr: "Testing sets:leading",
+ expr: "sets:leading($i, $empty)",
+ useCopyOf: true,
+ expResult: "<city name=\"Paris\" country=\"France\"></city><city name=\"Madrid\" country=\"Spain\"></city><city name=\"Vienna\" country=\"Austria\"></city><city name=\"Calais\" country=\"France\"></city><city name=\"Berlin\" country=\"Germany\"></city>",
+ },
+ {
+ descr: "Testing sets:trailing",
+ expr: "sets:trailing($i, $e)",
+ useCopyOf: true,
+ expResult: "<city name=\"Calais\" country=\"France\"></city><city name=\"Berlin\" country=\"Germany\"></city>",
+ },
+ {
+ descr: "Testing sets:trailing",
+ expr: "sets:trailing($i, $o)",
+ useCopyOf: true,
+ expResult: "",
+ },
+ {
+ descr: "Testing sets:trailing",
+ expr: "sets:trailing($i, $empty)",
+ useCopyOf: true,
+ expResult: "<city name=\"Paris\" country=\"France\"></city><city name=\"Madrid\" country=\"Spain\"></city><city name=\"Vienna\" country=\"Austria\"></city><city name=\"Calais\" country=\"France\"></city><city name=\"Berlin\" country=\"Germany\"></city>",
+ },
+ {
+ descr: "Testing strings:concat",
+ expr: "strings:concat(root/numbers/number/@id)",
+ expResult: "seveneleveneightfour",
+ },
+ {
+ descr: "Testing strings:split",
+ expr: "strings:split('a, simple, list', ', ')",
+ useCopyOf: true,
+ expResult: "<token>a</token><token>simple</token><token>list</token>",
+ },
+ {
+ descr: "Testing strings:split",
+ expr: "strings:split('date math str')",
+ useCopyOf: true,
+ expResult: "<token>date</token><token>math</token><token>str</token>",
+ },
+ {
+ descr: "Testing strings:split",
+ expr: "strings:split('foo', '')",
+ useCopyOf: true,
+ expResult: "<token>f</token><token>o</token><token>o</token>",
+ },
+ {
+ descr: "Testing strings:tokenize",
+ expr: "strings:tokenize('2001-06-03T11:40:23', '-T:')",
+ useCopyOf: true,
+ expResult: "<token>2001</token><token>06</token><token>03</token><token>11</token><token>40</token><token>23</token>",
+ },
+ {
+ descr: "Testing strings:tokenize",
+ expr: "strings:tokenize('date math str')",
+ useCopyOf: true,
+ expResult: "<token>date</token><token>math</token><token>str</token>",
+ },
+ {
+ descr: "Testing strings:tokenize",
+ expr: "strings:tokenize('foo', '')",
+ useCopyOf: true,
+ expResult: "<token>f</token><token>o</token><token>o</token>",
+ },
+ ];
+
+ let style =
+ `<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"
+ xmlns:common="http://exslt.org/common"
+ xmlns:math="http://exslt.org/math"
+ xmlns:regexp="http://exslt.org/regular-expressions"
+ xmlns:sets="http://exslt.org/sets"
+ xmlns:strings="http://exslt.org/strings">
+ <xsl:output method="html"/>
+ <xsl:variable name="tree"><abc>def</abc></xsl:variable>
+ <xsl:variable name="string" select="'abc'"/>
+ <xsl:variable name="number" select="123"/>
+ <xsl:variable name="boolean" select="true()"/>
+ <xsl:variable name="node-set" select="//*"/>
+ <xsl:variable name="i" select="/root/sets/city[contains(@name, 'i')]" />
+ <xsl:variable name="e" select="/root/sets/city[contains(@name, 'e')]" />
+ <xsl:variable name="o" select="/root/sets/city[contains(@name, 'o')]" />
+ <xsl:variable name="empty" select="/root/sets/city[contains(@name, 'x')]" />
+ <xsl:template match="/">
+ ${tests.map(({expr, useCopyOf}, i) => `<div id="${i}"><xsl:${useCopyOf ? "copy-of" : "value-of"} select="${expr}"/></div>`).join("\n")}
+ </xsl:template>
+ </xsl:stylesheet>`;
+
+ let styleDoc = new DOMParser().parseFromString(style, "text/xml");
+
+ let data = `<root>
+ <numbers>
+ <number id="seven">7</number>
+ <number id="eleven">11</number>
+ <number id="eight">8</number>
+ <number id="four">4</number>
+ </numbers>
+ <sets>
+ <city name="Paris" country="France" />
+ <city name="Madrid" country="Spain" />
+ <city name="Vienna" country="Austria" />
+ <city name="Barcelona" country="Spain" />
+ <city name="Salzburg" country="Austria" />
+ <city name="Bonn" country="Germany" />
+ <city name="Lyon" country="France" />
+ <city name="Hannover" country="Germany" />
+ <city name="Calais" country="France" />
+ <city name="Berlin" country="Germany" />
+ </sets>
+ </root>`;
+ let originalDoc = new DOMParser().parseFromString(data, "text/xml");
+
+ let processor = new XSLTProcessor();
+ processor.importStylesheet(styleDoc);
+
+ let fragment = processor.transformToFragment(originalDoc, document);
+
+ tests.forEach(({descr, expResult}, i) => {
+ let result = fragment.getElementById(i);
+ is(result.innerHTML, expResult, descr);
+ });
+
+</script>
+</pre>
+</body>
+</html>
diff --git a/dom/xslt/tests/mochitest/test_metaRefresh.html b/dom/xslt/tests/mochitest/test_metaRefresh.html
new file mode 100644
index 0000000000..21338bed82
--- /dev/null
+++ b/dom/xslt/tests/mochitest/test_metaRefresh.html
@@ -0,0 +1,48 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+ <meta charset="utf-8">
+ <title><!-- TODO: insert title here --></title>
+ <script src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" href="/tests/SimpleTest/test.css"/>
+ <script>
+ SimpleTest.waitForExplicitFinish();
+ SimpleTest.requestFlakyTimeout("Use a timeout to check that a load doesn't happen.");
+
+ async function runTest() {
+ function refreshed(frame) {
+ return new Promise((resolve) => {
+ frame.addEventListener("load", () => {
+ let timeout = setTimeout(() => {
+ resolve(false);
+ }, 5000);
+ frame.addEventListener("load", () => {
+ clearTimeout(timeout);
+ resolve(true);
+ }, { once: true });
+ }, { once: true });
+ });
+ }
+
+ let frame = document.getElementById("frame");
+ let result = refreshed(frame);
+ frame.src = "file_metaRefresh.xml";
+ is(await result, true, "Meta refresh should work in iframe document created by XSLT.");
+
+ let sandBoxedFrame = document.getElementById("sandBoxedFrame");
+ result = refreshed(sandBoxedFrame);
+ sandBoxedFrame.src = "file_metaRefresh.xml";
+ is(await result, false, "Meta refresh shouldn't work in sandboxed iframe document created by XSLT.");
+
+ SimpleTest.finish();
+ }
+ </script>
+</head>
+<body onload="runTest();">
+<p id="display"></p>
+<iframe id="frame"></iframe>
+<iframe sandbox="allow-same-origin" id="sandBoxedFrame"></iframe>
+<div id="content" style="display: none"></div>
+<pre id="test"></pre>
+</body>
+</html>
diff --git a/dom/xslt/tests/mochitest/test_parameter.html b/dom/xslt/tests/mochitest/test_parameter.html
new file mode 100644
index 0000000000..d2762d33be
--- /dev/null
+++ b/dom/xslt/tests/mochitest/test_parameter.html
@@ -0,0 +1,156 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+ <title>Test for setParameter/getParameter</title>
+ <script src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<p id="display"></p>
+<div id="content" style="display: none"><p id="number">123</p><p id="string">abc</p></div>
+<pre id="test">
+<script>
+ let processor = new XSLTProcessor();
+
+ processor.setParameter(null, "test", "hello");
+ is(processor.getParameter(null, "test"), "hello", "null namespace works");
+
+ processor.setParameter("foo", "bar", "foobar");
+ is(processor.getParameter("foo", "bar"), "foobar", "non-null namespace works");
+
+ processor.setParameter(null, "test", 123);
+ is(processor.getParameter(null, "test"), 123, "number value works");
+
+ processor.removeParameter(null, "test");
+ is(processor.getParameter(null, "test"), null, "removeParameter works");
+
+ is(processor.getParameter(null, "not-here"), null, "nonexistant parameter");
+
+ let parser = new DOMParser();
+ const style =
+ `<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"
+ xmlns:exslt="http://exslt.org/common">
+ <xsl:output method="html" />
+ <xsl:param name="test" />
+ <xsl:template match="/">
+ <p id="result"><xsl:value-of select="exslt:object-type($test)" /></p>
+ </xsl:template>
+ </xsl:stylesheet>`;
+ const styleDoc = parser.parseFromString(style, "text/xml");
+
+ const xml = `<root />`;
+ const sourceDoc = parser.parseFromString(xml, "text/xml");
+
+ function checkParameter(value, parameter) {
+ let valueType = typeof value;
+ switch (valueType) {
+ case "number":
+ case "boolean":
+ case "string":
+ is(typeof parameter, valueType, "Parameter has right type");
+ is(parameter, value, "Parameter has right value");
+ return;
+ case "object":
+ if (value instanceof Array || value instanceof NodeList) {
+ ok(parameter instanceof Array, "Parameter has right type");
+ ok(parameter.length == value.length &&
+ parameter.every((p, i) => value[i] === p),
+ "Parameter has right value");
+ return;
+ }
+
+ if (value instanceof Node) {
+ is(parameter, value, "Parameter has right value");
+ return;
+ }
+
+ if (value instanceof XPathResult) {
+ ok(parameter instanceof XPathResult, "Parameter has right type");
+ is(parameter.resultType, value.resultType, "Parameter has right inner type");
+ let valueProperty;
+ switch (value.resultType) {
+ case XPathResult.NUMBER_TYPE:
+ valueProperty = "numberValue";
+ break;
+ case XPathResult.BOOLEAN_TYPE:
+ valueProperty = "booleanValue";
+ break;
+ case XPathResult.STRING_TYPE:
+ valueProperty = "stringValue";
+ break;
+ case XPathResult.FIRST_ORDERED_NODE_TYPE:
+ valueProperty = "singleNodeValue";
+ break;
+ default:
+ ok(false, "Unexpected inner type");
+ return;
+ }
+ is(parameter[valueProperty], value[valueProperty], "Parameter has right value");
+ return;
+ }
+ }
+ ok(false, "Unexpected value");
+ }
+
+ function getXSLTType(value) {
+ let valueType = typeof value;
+ switch (valueType) {
+ case "number":
+ case "boolean":
+ case "string":
+ return valueType;
+ case "object":
+ if (value instanceof Array || value instanceof Node || value instanceof NodeList) {
+ return "node-set";
+ }
+ if (value instanceof XPathResult) {
+ switch (value.resultType) {
+ case XPathResult.NUMBER_TYPE:
+ return "number";
+ case XPathResult.BOOLEAN_TYPE:
+ return "boolean";
+ case XPathResult.STRING_TYPE:
+ return "string";
+ case XPathResult.FIRST_ORDERED_NODE_TYPE:
+ return "node-set";
+ }
+ }
+ }
+ ok(false, "Unexpected value");
+ }
+
+ function testParameter(value) {
+ let processor = new XSLTProcessor();
+
+ processor.setParameter(null, "test", value);
+ let parameter = processor.getParameter(null, "test");
+
+ checkParameter(value, parameter);
+
+ processor.importStylesheet(styleDoc);
+
+ let fragment = processor.transformToFragment(sourceDoc, document);
+
+ is(
+ fragment.getElementById("result").textContent,
+ getXSLTType(value),
+ "Global parameter has right type in XSLT."
+ );
+ }
+
+ testParameter(123);
+ testParameter(true);
+ testParameter("abcd");
+ testParameter([document]);
+ testParameter(document.documentElement.childNodes);
+ testParameter(document);
+ testParameter(document.evaluate("id('number')", document, null, XPathResult.NUMBER_TYPE));
+ testParameter(document.evaluate("/", document, null, XPathResult.BOOLEAN_TYPE));
+ testParameter(document.evaluate("id('string')", document, null, XPathResult.STRING_TYPE));
+ testParameter(
+ document.evaluate("/", document, null, XPathResult.FIRST_ORDERED_NODE_TYPE)
+ );
+</script>
+</pre>
+</body>
+</html>
diff --git a/dom/xslt/tests/mochitest/test_sorting_invalid_lang.html b/dom/xslt/tests/mochitest/test_sorting_invalid_lang.html
new file mode 100644
index 0000000000..6044e43309
--- /dev/null
+++ b/dom/xslt/tests/mochitest/test_sorting_invalid_lang.html
@@ -0,0 +1,82 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1734679
+-->
+<head>
+ <title>Test sorting with invalid lang</title>
+ <script src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1734679">Mozilla Bug 1734679</a>
+<p id="display"></p>
+<div id="content" style="display: none">
+
+</div>
+<pre id="test">
+<script class="testbody" type="text/javascript">
+
+/**
+ * Test for Bug 1734679. Invalid language tags should not throw an error, and should
+ * fall back to the app's locale.
+ * */
+
+var xmldoc, xsltdoc;
+
+xmldoc = new DOMParser().parseFromString('<?xml version="1.0" encoding="UTF-8"?>\n\
+ <?xml-stylesheet type="text/xsl" href="sort-lang.xsl" ?>\n\
+ <list>\n\
+ <entry>\n\
+ <technology>CSS</technology>\n\
+ <term>text-direction</term>\n\
+ </entry>\n\
+ <entry>\n\
+ <technology>JavaScript</technology>\n\
+ <term>Array.prototype.sort</term>\n\
+ </entry>\n\
+ </list>\n\
+ ', "text/xml");
+
+xsltdoc = new DOMParser().parseFromString('<?xml version="1.0" encoding="UTF-8"?>\n\
+ <xsl:stylesheet version="1.0"\n\
+ xmlns:xsl="http://www.w3.org/1999/XSL/Transform">\n\
+ <xsl:template match="/">\n\
+ <html>\n\
+ <body>\n\
+ <table border="1">\n\
+ <tr bgcolor="#9acd32">\n\
+ <th>Technology</th>\n\
+ <th>Term</th>\n\
+ </tr>\n\
+ <xsl:for-each select="list/entry">\n\
+ <xsl:sort select="term" lang="$invalidLanguageTag"/>\n\
+ <tr>\n\
+ <td><xsl:value-of select="technology"/></td>\n\
+ <td><xsl:value-of select="term"/></td>\n\
+ </tr>\n\
+ </xsl:for-each>\n\
+ </table>\n\
+ </body>\n\
+ </html>\n\
+ </xsl:template>\n\
+ \n\
+ </xsl:stylesheet>\n\
+ ', "text/xml");
+
+var processor = new XSLTProcessor;
+processor.importStylesheet(xsltdoc);
+
+try
+{
+ var result = processor.transformToDocument(xmldoc);
+}
+catch (e)
+{
+ ok(false, "There was an error.");
+}
+ok(result && result instanceof Document, "XSLT transform should have created a document");
+</script>
+</pre>
+</body>
+</html>
diff --git a/dom/xslt/xml/moz.build b/dom/xslt/xml/moz.build
new file mode 100644
index 0000000000..a8f33bd350
--- /dev/null
+++ b/dom/xslt/xml/moz.build
@@ -0,0 +1,19 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+UNIFIED_SOURCES += [
+ "txXMLParser.cpp",
+ "txXMLUtils.cpp",
+]
+
+LOCAL_INCLUDES += [
+ "../base",
+ "../xpath",
+ "../xslt",
+ "/dom/base",
+]
+
+FINAL_LIBRARY = "xul"
diff --git a/dom/xslt/xml/txXMLParser.cpp b/dom/xslt/xml/txXMLParser.cpp
new file mode 100644
index 0000000000..b769d6f17e
--- /dev/null
+++ b/dom/xslt/xml/txXMLParser.cpp
@@ -0,0 +1,59 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txXMLParser.h"
+#include "txURIUtils.h"
+#include "txXPathTreeWalker.h"
+
+#include "mozilla/dom/Document.h"
+#include "nsSyncLoadService.h"
+#include "nsNetUtil.h"
+#include "nsIURI.h"
+
+using namespace mozilla::dom;
+
+nsresult txParseDocumentFromURI(const nsAString& aHref,
+ const txXPathNode& aLoader, nsAString& aErrMsg,
+ txXPathNode** aResult) {
+ NS_ENSURE_ARG_POINTER(aResult);
+ *aResult = nullptr;
+ nsCOMPtr<nsIURI> documentURI;
+ nsresult rv = NS_NewURI(getter_AddRefs(documentURI), aHref);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ Document* loaderDocument = txXPathNativeNode::getDocument(aLoader);
+
+ nsCOMPtr<nsILoadGroup> loadGroup = loaderDocument->GetDocumentLoadGroup();
+
+ // For the system principal loaderUri will be null here, which is good
+ // since that means that chrome documents can load any uri.
+
+ // Raw pointer, we want the resulting txXPathNode to hold a reference to
+ // the document.
+ Document* theDocument = nullptr;
+ nsAutoSyncOperation sync(loaderDocument,
+ SyncOperationBehavior::eSuspendInput);
+ rv = nsSyncLoadService::LoadDocument(
+ documentURI, nsIContentPolicy::TYPE_INTERNAL_XMLHTTPREQUEST,
+ loaderDocument->NodePrincipal(),
+ nsILoadInfo::SEC_REQUIRE_CORS_INHERITS_SEC_CONTEXT, loadGroup,
+ loaderDocument->CookieJarSettings(), true,
+ loaderDocument->GetReferrerPolicy(), &theDocument);
+
+ if (NS_FAILED(rv)) {
+ aErrMsg.AppendLiteral("Document load of ");
+ aErrMsg.Append(aHref);
+ aErrMsg.AppendLiteral(" failed.");
+ return NS_FAILED(rv) ? rv : NS_ERROR_FAILURE;
+ }
+
+ *aResult = txXPathNativeNode::createXPathNode(theDocument);
+ if (!*aResult) {
+ NS_RELEASE(theDocument);
+ return NS_ERROR_FAILURE;
+ }
+
+ return NS_OK;
+}
diff --git a/dom/xslt/xml/txXMLParser.h b/dom/xslt/xml/txXMLParser.h
new file mode 100644
index 0000000000..83f2221506
--- /dev/null
+++ b/dom/xslt/xml/txXMLParser.h
@@ -0,0 +1,27 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef MITRE_XMLPARSER_H
+#define MITRE_XMLPARSER_H
+
+#include "txCore.h"
+
+class txXPathNode;
+
+/**
+ * API to load XML files into DOM datastructures.
+ * Parsing is either done by expat, or by expat via the syncloaderservice
+ */
+
+/**
+ * Parse a document from the aHref location, with referrer URI on behalf
+ * of the document aLoader.
+ */
+extern "C" nsresult txParseDocumentFromURI(const nsAString& aHref,
+ const txXPathNode& aLoader,
+ nsAString& aErrMsg,
+ txXPathNode** aResult);
+
+#endif
diff --git a/dom/xslt/xml/txXMLUtils.cpp b/dom/xslt/xml/txXMLUtils.cpp
new file mode 100644
index 0000000000..0688939ccb
--- /dev/null
+++ b/dom/xslt/xml/txXMLUtils.cpp
@@ -0,0 +1,164 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+ * XML utility classes
+ */
+
+#include "txXMLUtils.h"
+#include "nsString.h"
+#include "nsReadableUtils.h"
+#include "nsGkAtoms.h"
+#include "txStringUtils.h"
+#include "txNamespaceMap.h"
+#include "txXPathTreeWalker.h"
+#include "nsContentUtils.h"
+
+//------------------------------/
+//- Implementation of XMLUtils -/
+//------------------------------/
+
+// static
+nsresult XMLUtils::splitExpatName(const char16_t* aExpatName, nsAtom** aPrefix,
+ nsAtom** aLocalName, int32_t* aNameSpaceID) {
+ /**
+ * Expat can send the following:
+ * localName
+ * namespaceURI<separator>localName
+ * namespaceURI<separator>localName<separator>prefix
+ */
+
+ const char16_t* uriEnd = nullptr;
+ const char16_t* nameEnd = nullptr;
+ const char16_t* pos;
+ for (pos = aExpatName; *pos; ++pos) {
+ if (*pos == kExpatSeparatorChar) {
+ if (uriEnd) {
+ nameEnd = pos;
+ } else {
+ uriEnd = pos;
+ }
+ }
+ }
+
+ const char16_t* nameStart;
+ if (uriEnd) {
+ *aNameSpaceID = txNamespaceManager::getNamespaceID(
+ nsDependentSubstring(aExpatName, uriEnd));
+ if (*aNameSpaceID == kNameSpaceID_Unknown) {
+ return NS_ERROR_FAILURE;
+ }
+
+ nameStart = (uriEnd + 1);
+ if (nameEnd) {
+ const char16_t* prefixStart = nameEnd + 1;
+ *aPrefix = NS_Atomize(Substring(prefixStart, pos)).take();
+ if (!*aPrefix) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+ } else {
+ nameEnd = pos;
+ *aPrefix = nullptr;
+ }
+ } else {
+ *aNameSpaceID = kNameSpaceID_None;
+ nameStart = aExpatName;
+ nameEnd = pos;
+ *aPrefix = nullptr;
+ }
+
+ *aLocalName = NS_Atomize(Substring(nameStart, nameEnd)).take();
+
+ return *aLocalName ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+nsresult XMLUtils::splitQName(const nsAString& aName, nsAtom** aPrefix,
+ nsAtom** aLocalName) {
+ const char16_t* colon;
+ bool valid = XMLUtils::isValidQName(aName, &colon);
+ if (!valid) {
+ return NS_ERROR_FAILURE;
+ }
+
+ if (colon) {
+ const char16_t* end;
+ aName.EndReading(end);
+
+ *aPrefix = NS_Atomize(Substring(aName.BeginReading(), colon)).take();
+ *aLocalName = NS_Atomize(Substring(colon + 1, end)).take();
+ } else {
+ *aPrefix = nullptr;
+ *aLocalName = NS_Atomize(aName).take();
+ }
+
+ return NS_OK;
+}
+
+/**
+ * Returns true if the given string has only whitespace characters
+ */
+bool XMLUtils::isWhitespace(const nsAString& aText) {
+ nsString::const_char_iterator start, end;
+ aText.BeginReading(start);
+ aText.EndReading(end);
+ for (; start != end; ++start) {
+ if (!isWhitespace(*start)) {
+ return false;
+ }
+ }
+ return true;
+}
+
+/**
+ * Normalizes the value of a XML processing instruction
+ **/
+void XMLUtils::normalizePIValue(nsAString& piValue) {
+ nsAutoString origValue(piValue);
+ uint32_t origLength = origValue.Length();
+ uint32_t conversionLoop = 0;
+ char16_t prevCh = 0;
+ piValue.Truncate();
+
+ while (conversionLoop < origLength) {
+ char16_t ch = origValue.CharAt(conversionLoop);
+ switch (ch) {
+ case '>': {
+ if (prevCh == '?') {
+ piValue.Append(char16_t(' '));
+ }
+ break;
+ }
+ default: {
+ break;
+ }
+ }
+ piValue.Append(ch);
+ prevCh = ch;
+ ++conversionLoop;
+ }
+}
+
+// static
+bool XMLUtils::isValidQName(const nsAString& aQName, const char16_t** aColon) {
+ return NS_SUCCEEDED(nsContentUtils::CheckQName(aQName, true, aColon));
+}
+
+// static
+bool XMLUtils::getXMLSpacePreserve(const txXPathNode& aNode) {
+ nsAutoString value;
+ txXPathTreeWalker walker(aNode);
+ do {
+ if (walker.getAttr(nsGkAtoms::space, kNameSpaceID_XML, value)) {
+ if (TX_StringEqualsAtom(value, nsGkAtoms::preserve)) {
+ return true;
+ }
+ if (TX_StringEqualsAtom(value, nsGkAtoms::_default)) {
+ return false;
+ }
+ }
+ } while (walker.moveToParent());
+
+ return false;
+}
diff --git a/dom/xslt/xml/txXMLUtils.h b/dom/xslt/xml/txXMLUtils.h
new file mode 100644
index 0000000000..e7723fbaca
--- /dev/null
+++ b/dom/xslt/xml/txXMLUtils.h
@@ -0,0 +1,75 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * An XML Utility class
+ **/
+
+#ifndef MITRE_XMLUTILS_H
+#define MITRE_XMLUTILS_H
+
+#include "txCore.h"
+#include "nsDependentSubstring.h"
+#include "txXPathNode.h"
+
+#define kExpatSeparatorChar 0xFFFF
+
+extern "C" int MOZ_XMLIsLetter(const char* ptr);
+extern "C" int MOZ_XMLIsNCNameChar(const char* ptr);
+
+class nsAtom;
+
+class XMLUtils {
+ public:
+ static nsresult splitExpatName(const char16_t* aExpatName, nsAtom** aPrefix,
+ nsAtom** aLocalName, int32_t* aNameSpaceID);
+ static nsresult splitQName(const nsAString& aName, nsAtom** aPrefix,
+ nsAtom** aLocalName);
+
+ /*
+ * Returns true if the given character is whitespace.
+ */
+ static bool isWhitespace(const char16_t& aChar) {
+ return (aChar <= ' ' &&
+ (aChar == ' ' || aChar == '\r' || aChar == '\n' || aChar == '\t'));
+ }
+
+ /**
+ * Returns true if the given string has only whitespace characters
+ */
+ static bool isWhitespace(const nsAString& aText);
+
+ /**
+ * Normalizes the value of a XML processingInstruction
+ **/
+ static void normalizePIValue(nsAString& attValue);
+
+ /**
+ * Returns true if the given string is a valid XML QName
+ */
+ static bool isValidQName(const nsAString& aQName, const char16_t** aColon);
+
+ /**
+ * Returns true if the given character represents an Alpha letter
+ */
+ static bool isLetter(char16_t aChar) {
+ return !!MOZ_XMLIsLetter(reinterpret_cast<const char*>(&aChar));
+ }
+
+ /**
+ * Returns true if the given character is an allowable NCName character
+ */
+ static bool isNCNameChar(char16_t aChar) {
+ return !!MOZ_XMLIsNCNameChar(reinterpret_cast<const char*>(&aChar));
+ }
+
+ /*
+ * Walks up the document tree and returns true if the closest xml:space
+ * attribute is "preserve"
+ */
+ static bool getXMLSpacePreserve(const txXPathNode& aNode);
+};
+
+#endif
diff --git a/dom/xslt/xpath/XPathEvaluator.cpp b/dom/xslt/xpath/XPathEvaluator.cpp
new file mode 100644
index 0000000000..0080ae6d45
--- /dev/null
+++ b/dom/xslt/xpath/XPathEvaluator.cpp
@@ -0,0 +1,188 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/dom/XPathEvaluator.h"
+
+#include <utility>
+
+#include "XPathResult.h"
+#include "mozilla/UniquePtrExtensions.h"
+#include "mozilla/dom/BindingUtils.h"
+#include "mozilla/dom/Document.h"
+#include "mozilla/dom/XPathEvaluatorBinding.h"
+#include "mozilla/dom/XPathExpression.h"
+#include "mozilla/dom/XPathNSResolverBinding.h"
+#include "nsAtom.h"
+#include "nsCOMPtr.h"
+#include "nsContentCID.h"
+#include "nsContentUtils.h"
+#include "nsDOMString.h"
+#include "nsError.h"
+#include "nsNameSpaceManager.h"
+#include "txExpr.h"
+#include "txExprParser.h"
+#include "txIXPathContext.h"
+#include "txURIUtils.h"
+
+namespace mozilla::dom {
+
+// txIParseContext implementation
+class XPathEvaluatorParseContext : public txIParseContext {
+ public:
+ XPathEvaluatorParseContext(XPathNSResolver* aResolver, bool aIsCaseSensitive)
+ : mResolver(aResolver),
+ mResolverNode(nullptr),
+ mLastError(NS_OK),
+ mIsCaseSensitive(aIsCaseSensitive) {}
+ XPathEvaluatorParseContext(nsINode* aResolver, bool aIsCaseSensitive)
+ : mResolver(nullptr),
+ mResolverNode(aResolver),
+ mLastError(NS_OK),
+ mIsCaseSensitive(aIsCaseSensitive) {}
+
+ nsresult getError() { return mLastError; }
+
+ nsresult resolveNamespacePrefix(nsAtom* aPrefix, int32_t& aID) override;
+ nsresult resolveFunctionCall(nsAtom* aName, int32_t aID,
+ FunctionCall** aFunction) override;
+ bool caseInsensitiveNameTests() override;
+ void SetErrorOffset(uint32_t aOffset) override;
+
+ private:
+ XPathNSResolver* mResolver;
+ nsINode* mResolverNode;
+ nsresult mLastError;
+ bool mIsCaseSensitive;
+};
+
+XPathEvaluator::XPathEvaluator(Document* aDocument)
+ : mDocument(do_GetWeakReference(aDocument)) {}
+
+XPathEvaluator::~XPathEvaluator() = default;
+
+XPathExpression* XPathEvaluator::CreateExpression(const nsAString& aExpression,
+ XPathNSResolver* aResolver,
+ ErrorResult& aRv) {
+ nsCOMPtr<Document> doc = do_QueryReferent(mDocument);
+ XPathEvaluatorParseContext pContext(aResolver,
+ !(doc && doc->IsHTMLDocument()));
+ return CreateExpression(aExpression, &pContext, doc, aRv);
+}
+
+XPathExpression* XPathEvaluator::CreateExpression(const nsAString& aExpression,
+ nsINode* aResolver,
+ ErrorResult& aRv) {
+ nsCOMPtr<Document> doc = do_QueryReferent(mDocument);
+ XPathEvaluatorParseContext pContext(aResolver,
+ !(doc && doc->IsHTMLDocument()));
+ return CreateExpression(aExpression, &pContext, doc, aRv);
+}
+
+XPathExpression* XPathEvaluator::CreateExpression(const nsAString& aExpression,
+ txIParseContext* aContext,
+ Document* aDocument,
+ ErrorResult& aRv) {
+ if (!mRecycler) {
+ mRecycler = new txResultRecycler;
+ }
+
+ UniquePtr<Expr> expression;
+ aRv = txExprParser::createExpr(PromiseFlatString(aExpression), aContext,
+ getter_Transfers(expression));
+ if (aRv.Failed()) {
+ if (!aRv.ErrorCodeIs(NS_ERROR_DOM_NAMESPACE_ERR)) {
+ aRv.SuppressException();
+ aRv.ThrowSyntaxError("The expression is not a legal expression");
+ }
+
+ return nullptr;
+ }
+
+ return new XPathExpression(std::move(expression), mRecycler, aDocument);
+}
+
+bool XPathEvaluator::WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto,
+ JS::MutableHandle<JSObject*> aReflector) {
+ return dom::XPathEvaluator_Binding::Wrap(aCx, this, aGivenProto, aReflector);
+}
+
+/* static */
+XPathEvaluator* XPathEvaluator::Constructor(const GlobalObject& aGlobal) {
+ return new XPathEvaluator(nullptr);
+}
+
+already_AddRefed<XPathResult> XPathEvaluator::Evaluate(
+ JSContext* aCx, const nsAString& aExpression, nsINode& aContextNode,
+ XPathNSResolver* aResolver, uint16_t aType, JS::Handle<JSObject*> aResult,
+ ErrorResult& rv) {
+ UniquePtr<XPathExpression> expression(
+ CreateExpression(aExpression, aResolver, rv));
+ if (rv.Failed()) {
+ return nullptr;
+ }
+ return expression->Evaluate(aCx, aContextNode, aType, aResult, rv);
+}
+
+/*
+ * Implementation of txIParseContext private to XPathEvaluator, based on a
+ * XPathNSResolver
+ */
+
+nsresult XPathEvaluatorParseContext::resolveNamespacePrefix(nsAtom* aPrefix,
+ int32_t& aID) {
+ aID = kNameSpaceID_Unknown;
+
+ if (!mResolver && !mResolverNode) {
+ return NS_ERROR_DOM_NAMESPACE_ERR;
+ }
+
+ nsAutoString prefix;
+ if (aPrefix) {
+ aPrefix->ToString(prefix);
+ }
+
+ nsAutoString ns;
+ if (mResolver) {
+ ErrorResult rv;
+ mResolver->LookupNamespaceURI(prefix, ns, rv);
+ if (rv.Failed()) {
+ return rv.StealNSResult();
+ }
+ } else {
+ if (aPrefix == nsGkAtoms::xml) {
+ ns.AssignLiteral("http://www.w3.org/XML/1998/namespace");
+ } else {
+ mResolverNode->LookupNamespaceURI(prefix, ns);
+ }
+ }
+
+ if (DOMStringIsNull(ns)) {
+ return NS_ERROR_DOM_NAMESPACE_ERR;
+ }
+
+ if (ns.IsEmpty()) {
+ aID = kNameSpaceID_None;
+
+ return NS_OK;
+ }
+
+ // get the namespaceID for the URI
+ return nsNameSpaceManager::GetInstance()->RegisterNameSpace(ns, aID);
+}
+
+nsresult XPathEvaluatorParseContext::resolveFunctionCall(nsAtom* aName,
+ int32_t aID,
+ FunctionCall** aFn) {
+ return NS_ERROR_XPATH_UNKNOWN_FUNCTION;
+}
+
+bool XPathEvaluatorParseContext::caseInsensitiveNameTests() {
+ return !mIsCaseSensitive;
+}
+
+void XPathEvaluatorParseContext::SetErrorOffset(uint32_t aOffset) {}
+
+} // namespace mozilla::dom
diff --git a/dom/xslt/xpath/XPathEvaluator.h b/dom/xslt/xpath/XPathEvaluator.h
new file mode 100644
index 0000000000..7401d93214
--- /dev/null
+++ b/dom/xslt/xpath/XPathEvaluator.h
@@ -0,0 +1,66 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_dom_XPathEvaluator_h
+#define mozilla_dom_XPathEvaluator_h
+
+#include "mozilla/dom/NonRefcountedDOMObject.h"
+#include "nsString.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/dom/Document.h"
+
+class nsINode;
+class txIParseContext;
+class txResultRecycler;
+
+namespace mozilla {
+class ErrorResult;
+
+namespace dom {
+
+class GlobalObject;
+class XPathExpression;
+class XPathNSResolver;
+class XPathResult;
+
+/**
+ * A class for evaluating an XPath expression string
+ */
+class XPathEvaluator final : public NonRefcountedDOMObject {
+ public:
+ explicit XPathEvaluator(Document* aDocument = nullptr);
+ ~XPathEvaluator();
+
+ // WebIDL API
+ bool WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto,
+ JS::MutableHandle<JSObject*> aReflector);
+ Document* GetParentObject() {
+ nsCOMPtr<Document> doc = do_QueryReferent(mDocument);
+ return doc;
+ }
+ static XPathEvaluator* Constructor(const GlobalObject& aGlobal);
+ XPathExpression* CreateExpression(const nsAString& aExpression,
+ XPathNSResolver* aResolver,
+ ErrorResult& rv);
+ XPathExpression* CreateExpression(const nsAString& aExpression,
+ nsINode* aResolver, ErrorResult& aRv);
+ XPathExpression* CreateExpression(const nsAString& aExpression,
+ txIParseContext* aContext,
+ Document* aDocument, ErrorResult& aRv);
+ nsINode* CreateNSResolver(nsINode& aNodeResolver) { return &aNodeResolver; }
+ already_AddRefed<XPathResult> Evaluate(
+ JSContext* aCx, const nsAString& aExpression, nsINode& aContextNode,
+ XPathNSResolver* aResolver, uint16_t aType, JS::Handle<JSObject*> aResult,
+ ErrorResult& rv);
+
+ private:
+ nsWeakPtr mDocument;
+ RefPtr<txResultRecycler> mRecycler;
+};
+
+} // namespace dom
+} // namespace mozilla
+
+#endif /* mozilla_dom_XPathEvaluator_h */
diff --git a/dom/xslt/xpath/XPathExpression.cpp b/dom/xslt/xpath/XPathExpression.cpp
new file mode 100644
index 0000000000..0706763d79
--- /dev/null
+++ b/dom/xslt/xpath/XPathExpression.cpp
@@ -0,0 +1,210 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "XPathExpression.h"
+
+#include <utility>
+
+#include "XPathResult.h"
+#include "mozilla/dom/BindingUtils.h"
+#include "mozilla/dom/Text.h"
+#include "mozilla/dom/XPathResultBinding.h"
+#include "nsError.h"
+#include "nsINode.h"
+#include "txExpr.h"
+#include "txExprResult.h"
+#include "txIXPathContext.h"
+#include "txURIUtils.h"
+#include "txXPathTreeWalker.h"
+
+namespace mozilla::dom {
+
+class EvalContextImpl : public txIEvalContext {
+ public:
+ EvalContextImpl(const txXPathNode& aContextNode, uint32_t aContextPosition,
+ uint32_t aContextSize, txResultRecycler* aRecycler)
+ : mContextNode(aContextNode),
+ mContextPosition(aContextPosition),
+ mContextSize(aContextSize),
+ mLastError(NS_OK),
+ mRecycler(aRecycler) {}
+
+ nsresult getError() { return mLastError; }
+
+ TX_DECL_EVAL_CONTEXT;
+
+ private:
+ const txXPathNode& mContextNode;
+ uint32_t mContextPosition;
+ uint32_t mContextSize;
+ nsresult mLastError;
+ RefPtr<txResultRecycler> mRecycler;
+};
+
+XPathExpression::XPathExpression(UniquePtr<Expr>&& aExpression,
+ txResultRecycler* aRecycler,
+ Document* aDocument)
+ : mExpression(std::move(aExpression)),
+ mRecycler(aRecycler),
+ mDocument(do_GetWeakReference(aDocument)),
+ mCheckDocument(aDocument != nullptr) {}
+
+XPathExpression::~XPathExpression() = default;
+
+already_AddRefed<XPathResult> XPathExpression::EvaluateWithContext(
+ JSContext* aCx, nsINode& aContextNode, uint32_t aContextPosition,
+ uint32_t aContextSize, uint16_t aType, JS::Handle<JSObject*> aInResult,
+ ErrorResult& aRv) {
+ RefPtr<XPathResult> inResult;
+ if (aInResult) {
+ nsresult rv = UNWRAP_OBJECT(XPathResult, aInResult, inResult);
+ if (NS_FAILED(rv) && rv != NS_ERROR_XPC_BAD_CONVERT_JS) {
+ aRv.Throw(rv);
+ return nullptr;
+ }
+ }
+
+ return EvaluateWithContext(aContextNode, aContextPosition, aContextSize,
+ aType, inResult, aRv);
+}
+
+already_AddRefed<XPathResult> XPathExpression::EvaluateWithContext(
+ nsINode& aContextNode, uint32_t aContextPosition, uint32_t aContextSize,
+ uint16_t aType, XPathResult* aInResult, ErrorResult& aRv) {
+ if (aContextPosition > aContextSize) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+
+ if (aType > XPathResult_Binding::FIRST_ORDERED_NODE_TYPE) {
+ aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
+ return nullptr;
+ }
+
+ if (!nsContentUtils::LegacyIsCallerNativeCode() &&
+ !nsContentUtils::CanCallerAccess(&aContextNode)) {
+ aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
+ return nullptr;
+ }
+
+ if (mCheckDocument) {
+ nsCOMPtr<Document> doc = do_QueryReferent(mDocument);
+ if (doc != aContextNode.OwnerDoc()) {
+ aRv.Throw(NS_ERROR_DOM_WRONG_DOCUMENT_ERR);
+ return nullptr;
+ }
+ }
+
+ uint16_t nodeType = aContextNode.NodeType();
+
+ if (nodeType == nsINode::TEXT_NODE ||
+ nodeType == nsINode::CDATA_SECTION_NODE) {
+ Text* textNode = aContextNode.GetAsText();
+ MOZ_ASSERT(textNode);
+
+ uint32_t textLength = textNode->Length();
+ if (textLength == 0) {
+ aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
+ return nullptr;
+ }
+
+ // XXX Need to get logical XPath text node for CDATASection
+ // and Text nodes.
+ } else if (nodeType != nsINode::DOCUMENT_NODE &&
+ nodeType != nsINode::ELEMENT_NODE &&
+ nodeType != nsINode::ATTRIBUTE_NODE &&
+ nodeType != nsINode::COMMENT_NODE &&
+ nodeType != nsINode::PROCESSING_INSTRUCTION_NODE) {
+ aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
+ return nullptr;
+ }
+
+ UniquePtr<txXPathNode> contextNode(
+ txXPathNativeNode::createXPathNode(&aContextNode));
+ if (!contextNode) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+
+ EvalContextImpl eContext(*contextNode, aContextPosition, aContextSize,
+ mRecycler);
+ RefPtr<txAExprResult> exprResult;
+ aRv = mExpression->evaluate(&eContext, getter_AddRefs(exprResult));
+ if (aRv.Failed()) {
+ return nullptr;
+ }
+
+ uint16_t resultType = aType;
+ if (aType == XPathResult::ANY_TYPE) {
+ short exprResultType = exprResult->getResultType();
+ switch (exprResultType) {
+ case txAExprResult::NUMBER:
+ resultType = XPathResult::NUMBER_TYPE;
+ break;
+ case txAExprResult::STRING:
+ resultType = XPathResult::STRING_TYPE;
+ break;
+ case txAExprResult::BOOLEAN:
+ resultType = XPathResult::BOOLEAN_TYPE;
+ break;
+ case txAExprResult::NODESET:
+ resultType = XPathResult::UNORDERED_NODE_ITERATOR_TYPE;
+ break;
+ case txAExprResult::RESULT_TREE_FRAGMENT:
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+ }
+
+ RefPtr<XPathResult> xpathResult = aInResult;
+ if (!xpathResult) {
+ xpathResult = new XPathResult(&aContextNode);
+ }
+
+ xpathResult->SetExprResult(exprResult, resultType, &aContextNode, aRv);
+ if (aRv.Failed()) {
+ return nullptr;
+ }
+
+ return xpathResult.forget();
+}
+
+/*
+ * Implementation of the txIEvalContext private to XPathExpression
+ * EvalContextImpl bases on only one context node and no variables
+ */
+
+nsresult EvalContextImpl::getVariable(int32_t aNamespace, nsAtom* aLName,
+ txAExprResult*& aResult) {
+ aResult = 0;
+ return NS_ERROR_INVALID_ARG;
+}
+
+nsresult EvalContextImpl::isStripSpaceAllowed(const txXPathNode& aNode,
+ bool& aAllowed) {
+ aAllowed = false;
+
+ return NS_OK;
+}
+
+void* EvalContextImpl::getPrivateContext() {
+ // we don't have a private context here.
+ return nullptr;
+}
+
+txResultRecycler* EvalContextImpl::recycler() { return mRecycler; }
+
+void EvalContextImpl::receiveError(const nsAString& aMsg, nsresult aRes) {
+ mLastError = aRes;
+ // forward aMsg to console service?
+}
+
+const txXPathNode& EvalContextImpl::getContextNode() { return mContextNode; }
+
+uint32_t EvalContextImpl::size() { return mContextSize; }
+
+uint32_t EvalContextImpl::position() { return mContextPosition; }
+
+} // namespace mozilla::dom
diff --git a/dom/xslt/xpath/XPathExpression.h b/dom/xslt/xpath/XPathExpression.h
new file mode 100644
index 0000000000..e041649395
--- /dev/null
+++ b/dom/xslt/xpath/XPathExpression.h
@@ -0,0 +1,68 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_dom_XPathExpression_h
+#define mozilla_dom_XPathExpression_h
+
+#include "nsCycleCollectionParticipant.h"
+#include "nsIWeakReferenceUtils.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/dom/NonRefcountedDOMObject.h"
+#include "mozilla/dom/XPathExpressionBinding.h"
+#include "mozilla/UniquePtr.h"
+
+class Expr;
+
+class nsINode;
+class txResultRecycler;
+
+namespace mozilla::dom {
+
+class Document;
+class XPathResult;
+
+/**
+ * A class for evaluating an XPath expression string
+ */
+class XPathExpression final : public NonRefcountedDOMObject {
+ public:
+ XPathExpression(mozilla::UniquePtr<Expr>&& aExpression,
+ txResultRecycler* aRecycler, Document* aDocument);
+ ~XPathExpression();
+
+ bool WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto,
+ JS::MutableHandle<JSObject*> aReflector) {
+ return XPathExpression_Binding::Wrap(aCx, this, aGivenProto, aReflector);
+ }
+
+ already_AddRefed<XPathResult> Evaluate(JSContext* aCx, nsINode& aContextNode,
+ uint16_t aType,
+ JS::Handle<JSObject*> aInResult,
+ ErrorResult& aRv) {
+ return EvaluateWithContext(aCx, aContextNode, 1, 1, aType, aInResult, aRv);
+ }
+ already_AddRefed<XPathResult> EvaluateWithContext(
+ JSContext* aCx, nsINode& aContextNode, uint32_t aContextPosition,
+ uint32_t aContextSize, uint16_t aType, JS::Handle<JSObject*> aInResult,
+ ErrorResult& aRv);
+ already_AddRefed<XPathResult> Evaluate(nsINode& aContextNode, uint16_t aType,
+ XPathResult* aInResult,
+ ErrorResult& aRv) {
+ return EvaluateWithContext(aContextNode, 1, 1, aType, aInResult, aRv);
+ }
+ already_AddRefed<XPathResult> EvaluateWithContext(
+ nsINode& aContextNode, uint32_t aContextPosition, uint32_t aContextSize,
+ uint16_t aType, XPathResult* aInResult, ErrorResult& aRv);
+
+ private:
+ mozilla::UniquePtr<Expr> mExpression;
+ RefPtr<txResultRecycler> mRecycler;
+ nsWeakPtr mDocument;
+ bool mCheckDocument;
+};
+
+} // namespace mozilla::dom
+
+#endif /* mozilla_dom_XPathExpression_h */
diff --git a/dom/xslt/xpath/XPathResult.cpp b/dom/xslt/xpath/XPathResult.cpp
new file mode 100644
index 0000000000..091a83528f
--- /dev/null
+++ b/dom/xslt/xpath/XPathResult.cpp
@@ -0,0 +1,264 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "XPathResult.h"
+#include "txExprResult.h"
+#include "txNodeSet.h"
+#include "nsError.h"
+#include "mozilla/dom/Attr.h"
+#include "mozilla/dom/Element.h"
+#include "nsDOMString.h"
+#include "txXPathTreeWalker.h"
+#include "nsCycleCollectionParticipant.h"
+#include "mozilla/dom/XPathResultBinding.h"
+
+namespace mozilla::dom {
+
+XPathResult::XPathResult(nsINode* aParent)
+ : mParent(aParent),
+ mDocument(nullptr),
+ mCurrentPos(0),
+ mResultType(ANY_TYPE),
+ mInvalidIteratorState(true),
+ mBooleanResult(false),
+ mNumberResult(0) {}
+
+XPathResult::XPathResult(const XPathResult& aResult)
+ : mParent(aResult.mParent),
+ mResult(aResult.mResult),
+ mResultNodes(aResult.mResultNodes.Clone()),
+ mDocument(aResult.mDocument),
+ mContextNode(aResult.mContextNode),
+ mCurrentPos(0),
+ mResultType(aResult.mResultType),
+ mInvalidIteratorState(aResult.mInvalidIteratorState),
+ mBooleanResult(aResult.mBooleanResult),
+ mNumberResult(aResult.mNumberResult),
+ mStringResult(aResult.mStringResult) {
+ if (mDocument) {
+ mDocument->AddMutationObserver(this);
+ }
+}
+
+XPathResult::~XPathResult() { RemoveObserver(); }
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(XPathResult)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(XPathResult)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mParent) { tmp->RemoveObserver(); }
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mDocument)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(XPathResult)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mParent)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDocument)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mResultNodes)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(XPathResult)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(XPathResult)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(XPathResult)
+ NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+ NS_INTERFACE_MAP_ENTRY(nsIMutationObserver)
+ NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+JSObject* XPathResult::WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) {
+ return XPathResult_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+void XPathResult::RemoveObserver() {
+ if (mDocument) {
+ mDocument->RemoveMutationObserver(this);
+ }
+}
+
+nsINode* XPathResult::IterateNext(ErrorResult& aRv) {
+ if (!isIterator()) {
+ aRv.ThrowTypeError("Result is not an iterator");
+ return nullptr;
+ }
+
+ if (mDocument) {
+ mDocument->FlushPendingNotifications(FlushType::Content);
+ }
+
+ if (mInvalidIteratorState) {
+ aRv.ThrowInvalidStateError(
+ "The document has been mutated since the result was returned");
+ return nullptr;
+ }
+
+ return mResultNodes.SafeElementAt(mCurrentPos++);
+}
+
+void XPathResult::NodeWillBeDestroyed(nsINode* aNode) {
+ nsCOMPtr<nsIMutationObserver> kungFuDeathGrip(this);
+ // Set to null to avoid unregistring unnecessarily
+ mDocument = nullptr;
+ Invalidate(aNode->IsContent() ? aNode->AsContent() : nullptr);
+}
+
+void XPathResult::CharacterDataChanged(nsIContent* aContent,
+ const CharacterDataChangeInfo&) {
+ Invalidate(aContent);
+}
+
+void XPathResult::AttributeChanged(Element* aElement, int32_t aNameSpaceID,
+ nsAtom* aAttribute, int32_t aModType,
+ const nsAttrValue* aOldValue) {
+ Invalidate(aElement);
+}
+
+void XPathResult::ContentAppended(nsIContent* aFirstNewContent) {
+ Invalidate(aFirstNewContent->GetParent());
+}
+
+void XPathResult::ContentInserted(nsIContent* aChild) {
+ Invalidate(aChild->GetParent());
+}
+
+void XPathResult::ContentRemoved(nsIContent* aChild,
+ nsIContent* aPreviousSibling) {
+ Invalidate(aChild->GetParent());
+}
+
+void XPathResult::SetExprResult(txAExprResult* aExprResult,
+ uint16_t aResultType, nsINode* aContextNode,
+ ErrorResult& aRv) {
+ MOZ_ASSERT(aExprResult);
+
+ if ((isSnapshot(aResultType) || isIterator(aResultType) ||
+ isNode(aResultType)) &&
+ aExprResult->getResultType() != txAExprResult::NODESET) {
+ // The DOM spec doesn't really say what should happen when reusing an
+ // XPathResult and an error is thrown. Let's not touch the XPathResult
+ // in that case.
+ aRv.ThrowTypeError("Result type mismatch");
+ return;
+ }
+
+ mResultType = aResultType;
+ mContextNode = do_GetWeakReference(aContextNode);
+
+ if (mDocument) {
+ mDocument->RemoveMutationObserver(this);
+ mDocument = nullptr;
+ }
+
+ mResultNodes.Clear();
+
+ // XXX This will keep the recycler alive, should we clear it?
+ mResult = aExprResult;
+ switch (mResultType) {
+ case BOOLEAN_TYPE: {
+ mBooleanResult = mResult->booleanValue();
+ break;
+ }
+ case NUMBER_TYPE: {
+ mNumberResult = mResult->numberValue();
+ break;
+ }
+ case STRING_TYPE: {
+ mResult->stringValue(mStringResult);
+ break;
+ }
+ default: {
+ MOZ_ASSERT(isNode() || isIterator() || isSnapshot());
+ }
+ }
+
+ if (aExprResult->getResultType() == txAExprResult::NODESET) {
+ txNodeSet* nodeSet = static_cast<txNodeSet*>(aExprResult);
+ int32_t i, count = nodeSet->size();
+ for (i = 0; i < count; ++i) {
+ nsINode* node = txXPathNativeNode::getNode(nodeSet->get(i));
+ mResultNodes.AppendElement(node);
+ }
+
+ if (count > 0) {
+ mResult = nullptr;
+ }
+ }
+
+ if (!isIterator()) {
+ return;
+ }
+
+ mCurrentPos = 0;
+ mInvalidIteratorState = false;
+
+ if (!mResultNodes.IsEmpty()) {
+ // If we support the document() function in DOM-XPath we need to
+ // observe all documents that we have resultnodes in.
+ mDocument = mResultNodes[0]->OwnerDoc();
+ NS_ASSERTION(mDocument, "We need a document!");
+ if (mDocument) {
+ mDocument->AddMutationObserver(this);
+ }
+ }
+}
+
+void XPathResult::Invalidate(const nsIContent* aChangeRoot) {
+ nsCOMPtr<nsINode> contextNode = do_QueryReferent(mContextNode);
+ // If the changes are happening in a different anonymous trees, no
+ // invalidation should happen.
+ if (contextNode && aChangeRoot &&
+ !nsContentUtils::IsInSameAnonymousTree(contextNode, aChangeRoot)) {
+ return;
+ }
+
+ mInvalidIteratorState = true;
+ // Make sure nulling out mDocument is the last thing we do.
+ if (mDocument) {
+ mDocument->RemoveMutationObserver(this);
+ mDocument = nullptr;
+ }
+}
+
+nsresult XPathResult::GetExprResult(txAExprResult** aExprResult) {
+ if (isIterator() && mInvalidIteratorState) {
+ return NS_ERROR_DOM_INVALID_STATE_ERR;
+ }
+
+ if (mResult) {
+ NS_ADDREF(*aExprResult = mResult);
+
+ return NS_OK;
+ }
+
+ if (mResultNodes.IsEmpty()) {
+ return NS_ERROR_DOM_INVALID_STATE_ERR;
+ }
+
+ RefPtr<txNodeSet> nodeSet = new txNodeSet(nullptr);
+ uint32_t i, count = mResultNodes.Length();
+ for (i = 0; i < count; ++i) {
+ UniquePtr<txXPathNode> node(
+ txXPathNativeNode::createXPathNode(mResultNodes[i]));
+ if (!node) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ nodeSet->append(*node);
+ }
+
+ NS_ADDREF(*aExprResult = nodeSet);
+
+ return NS_OK;
+}
+
+already_AddRefed<XPathResult> XPathResult::Clone(ErrorResult& aError) {
+ if (isIterator() && mInvalidIteratorState) {
+ aError = NS_ERROR_DOM_INVALID_STATE_ERR;
+ return nullptr;
+ }
+
+ return do_AddRef(new XPathResult(*this));
+}
+
+} // namespace mozilla::dom
diff --git a/dom/xslt/xpath/XPathResult.h b/dom/xslt/xpath/XPathResult.h
new file mode 100644
index 0000000000..e073666a84
--- /dev/null
+++ b/dom/xslt/xpath/XPathResult.h
@@ -0,0 +1,156 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_dom_XPathResult_h
+#define mozilla_dom_XPathResult_h
+
+#include "nsStubMutationObserver.h"
+#include "nsCOMPtr.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsIWeakReferenceUtils.h"
+#include "nsTArray.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/ErrorResult.h"
+#include "nsString.h"
+#include "nsWrapperCache.h"
+#include "nsINode.h"
+
+class txAExprResult;
+
+namespace mozilla::dom {
+
+/**
+ * A class for evaluating an XPath expression string
+ */
+class XPathResult final : public nsStubMutationObserver, public nsWrapperCache {
+ ~XPathResult();
+
+ public:
+ explicit XPathResult(nsINode* aParent);
+ XPathResult(const XPathResult& aResult);
+
+ enum {
+ ANY_TYPE = 0U,
+ NUMBER_TYPE = 1U,
+ STRING_TYPE = 2U,
+ BOOLEAN_TYPE = 3U,
+ UNORDERED_NODE_ITERATOR_TYPE = 4U,
+ ORDERED_NODE_ITERATOR_TYPE = 5U,
+ UNORDERED_NODE_SNAPSHOT_TYPE = 6U,
+ ORDERED_NODE_SNAPSHOT_TYPE = 7U,
+ ANY_UNORDERED_NODE_TYPE = 8U,
+ FIRST_ORDERED_NODE_TYPE = 9U
+ };
+
+ // nsISupports interface
+ NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+ NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(XPathResult)
+
+ virtual JSObject* WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) override;
+ nsINode* GetParentObject() const { return mParent; }
+ uint16_t ResultType() const { return mResultType; }
+ double GetNumberValue(ErrorResult& aRv) const {
+ if (mResultType != NUMBER_TYPE) {
+ aRv.ThrowTypeError("Result is not a number");
+ return 0;
+ }
+
+ return mNumberResult;
+ }
+ void GetStringValue(nsAString& aStringValue, ErrorResult& aRv) const {
+ if (mResultType != STRING_TYPE) {
+ aRv.ThrowTypeError("Result is not a string");
+ return;
+ }
+
+ aStringValue = mStringResult;
+ }
+ bool GetBooleanValue(ErrorResult& aRv) const {
+ if (mResultType != BOOLEAN_TYPE) {
+ aRv.ThrowTypeError("Result is not a boolean");
+ return false;
+ }
+
+ return mBooleanResult;
+ }
+ nsINode* GetSingleNodeValue(ErrorResult& aRv) const {
+ if (!isNode()) {
+ aRv.ThrowTypeError("Result is not a node");
+ return nullptr;
+ }
+
+ return mResultNodes.SafeElementAt(0);
+ }
+ bool InvalidIteratorState() const {
+ return isIterator() && mInvalidIteratorState;
+ }
+ uint32_t GetSnapshotLength(ErrorResult& aRv) const {
+ if (!isSnapshot()) {
+ aRv.ThrowTypeError("Result is not a snapshot");
+ return 0;
+ }
+
+ return (uint32_t)mResultNodes.Length();
+ }
+ nsINode* IterateNext(ErrorResult& aRv);
+ nsINode* SnapshotItem(uint32_t aIndex, ErrorResult& aRv) const {
+ if (!isSnapshot()) {
+ aRv.ThrowTypeError("Result is not a snapshot");
+ return nullptr;
+ }
+
+ return mResultNodes.SafeElementAt(aIndex);
+ }
+
+ // nsIMutationObserver interface
+ NS_DECL_NSIMUTATIONOBSERVER_CHARACTERDATACHANGED
+ NS_DECL_NSIMUTATIONOBSERVER_ATTRIBUTECHANGED
+ NS_DECL_NSIMUTATIONOBSERVER_CONTENTAPPENDED
+ NS_DECL_NSIMUTATIONOBSERVER_CONTENTINSERTED
+ NS_DECL_NSIMUTATIONOBSERVER_CONTENTREMOVED
+ NS_DECL_NSIMUTATIONOBSERVER_NODEWILLBEDESTROYED
+
+ void SetExprResult(txAExprResult* aExprResult, uint16_t aResultType,
+ nsINode* aContextNode, ErrorResult& aRv);
+ nsresult GetExprResult(txAExprResult** aExprResult);
+ already_AddRefed<XPathResult> Clone(ErrorResult& aError);
+ void RemoveObserver();
+
+ private:
+ static bool isSnapshot(uint16_t aResultType) {
+ return aResultType == UNORDERED_NODE_SNAPSHOT_TYPE ||
+ aResultType == ORDERED_NODE_SNAPSHOT_TYPE;
+ }
+ static bool isIterator(uint16_t aResultType) {
+ return aResultType == UNORDERED_NODE_ITERATOR_TYPE ||
+ aResultType == ORDERED_NODE_ITERATOR_TYPE;
+ }
+ static bool isNode(uint16_t aResultType) {
+ return aResultType == FIRST_ORDERED_NODE_TYPE ||
+ aResultType == ANY_UNORDERED_NODE_TYPE;
+ }
+ bool isSnapshot() const { return isSnapshot(mResultType); }
+ bool isIterator() const { return isIterator(mResultType); }
+ bool isNode() const { return isNode(mResultType); }
+
+ void Invalidate(const nsIContent* aChangeRoot);
+
+ nsCOMPtr<nsINode> mParent;
+ RefPtr<txAExprResult> mResult;
+ nsTArray<nsCOMPtr<nsINode>> mResultNodes;
+ RefPtr<Document> mDocument;
+ nsWeakPtr mContextNode;
+ uint32_t mCurrentPos;
+ uint16_t mResultType;
+ bool mInvalidIteratorState;
+ bool mBooleanResult;
+ double mNumberResult;
+ nsString mStringResult;
+};
+
+} // namespace mozilla::dom
+
+#endif /* mozilla_dom_XPathResult_h */
diff --git a/dom/xslt/xpath/moz.build b/dom/xslt/xpath/moz.build
new file mode 100644
index 0000000000..9cf562c0af
--- /dev/null
+++ b/dom/xslt/xpath/moz.build
@@ -0,0 +1,58 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+EXPORTS.mozilla.dom += [
+ "txIXPathContext.h",
+ "XPathEvaluator.h",
+ "XPathExpression.h",
+ "XPathResult.h",
+]
+
+UNIFIED_SOURCES += [
+ "txBooleanExpr.cpp",
+ "txBooleanResult.cpp",
+ "txCoreFunctionCall.cpp",
+ "txErrorExpr.cpp",
+ "txExpr.cpp",
+ "txExprLexer.cpp",
+ "txExprParser.cpp",
+ "txFilterExpr.cpp",
+ "txForwardContext.cpp",
+ "txFunctionCall.cpp",
+ "txLiteralExpr.cpp",
+ "txLocationStep.cpp",
+ "txMozillaXPathTreeWalker.cpp",
+ "txNamedAttributeStep.cpp",
+ "txNameTest.cpp",
+ "txNodeSet.cpp",
+ "txNodeSetContext.cpp",
+ "txNodeTypeTest.cpp",
+ "txNumberExpr.cpp",
+ "txNumberResult.cpp",
+ "txPathExpr.cpp",
+ "txPredicatedNodeTest.cpp",
+ "txPredicateList.cpp",
+ "txRelationalExpr.cpp",
+ "txResultRecycler.cpp",
+ "txRootExpr.cpp",
+ "txStringResult.cpp",
+ "txUnaryExpr.cpp",
+ "txUnionExpr.cpp",
+ "txUnionNodeTest.cpp",
+ "txVariableRefExpr.cpp",
+ "txXPathOptimizer.cpp",
+ "XPathEvaluator.cpp",
+ "XPathExpression.cpp",
+ "XPathResult.cpp",
+]
+
+LOCAL_INCLUDES += [
+ "../base",
+ "../xml",
+ "../xslt",
+]
+
+FINAL_LIBRARY = "xul"
diff --git a/dom/xslt/xpath/txBooleanExpr.cpp b/dom/xslt/xpath/txBooleanExpr.cpp
new file mode 100644
index 0000000000..0f4366ff76
--- /dev/null
+++ b/dom/xslt/xpath/txBooleanExpr.cpp
@@ -0,0 +1,78 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Represents a BooleanExpr, a binary expression that
+ * performs a boolean operation between its lvalue and rvalue.
+ **/
+
+#include "txExpr.h"
+#include "txIXPathContext.h"
+
+/**
+ * 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 BooleanExpr::evaluate(txIEvalContext* aContext,
+ txAExprResult** aResult) {
+ *aResult = nullptr;
+
+ bool lval;
+ nsresult rv = leftExpr->evaluateToBool(aContext, lval);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // check for early decision
+ if (op == OR && lval) {
+ aContext->recycler()->getBoolResult(true, aResult);
+
+ return NS_OK;
+ }
+ if (op == AND && !lval) {
+ aContext->recycler()->getBoolResult(false, aResult);
+
+ return NS_OK;
+ }
+
+ bool rval;
+ rv = rightExpr->evaluateToBool(aContext, rval);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // just use rval, since we already checked lval
+ aContext->recycler()->getBoolResult(rval, aResult);
+
+ return NS_OK;
+} //-- evaluate
+
+TX_IMPL_EXPR_STUBS_2(BooleanExpr, BOOLEAN_RESULT, leftExpr, rightExpr)
+
+bool BooleanExpr::isSensitiveTo(ContextSensitivity aContext) {
+ return leftExpr->isSensitiveTo(aContext) ||
+ rightExpr->isSensitiveTo(aContext);
+}
+
+#ifdef TX_TO_STRING
+void BooleanExpr::toString(nsAString& str) {
+ if (leftExpr)
+ leftExpr->toString(str);
+ else
+ str.AppendLiteral("null");
+
+ switch (op) {
+ case OR:
+ str.AppendLiteral(" or ");
+ break;
+ default:
+ str.AppendLiteral(" and ");
+ break;
+ }
+ if (rightExpr)
+ rightExpr->toString(str);
+ else
+ str.AppendLiteral("null");
+}
+#endif
diff --git a/dom/xslt/xpath/txBooleanResult.cpp b/dom/xslt/xpath/txBooleanResult.cpp
new file mode 100644
index 0000000000..1d69a8c347
--- /dev/null
+++ b/dom/xslt/xpath/txBooleanResult.cpp
@@ -0,0 +1,48 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+ * Boolean Expression result
+ */
+
+#include "txExprResult.h"
+
+/**
+ * Creates a new BooleanResult with the value of the given bool parameter
+ * @param boolean the bool to use for initialization of this BooleanResult's
+ * value
+ **/
+BooleanResult::BooleanResult(bool boolean) : txAExprResult(nullptr) {
+ this->value = boolean;
+} //-- BooleanResult
+
+/*
+ * Virtual Methods from ExprResult
+ */
+
+short BooleanResult::getResultType() {
+ return txAExprResult::BOOLEAN;
+} //-- getResultType
+
+void BooleanResult::stringValue(nsString& aResult) {
+ if (value) {
+ aResult.AppendLiteral("true");
+ } else {
+ aResult.AppendLiteral("false");
+ }
+}
+
+const nsString* BooleanResult::stringValuePointer() {
+ // In theory we could set strings containing "true" and "false" somewhere,
+ // but most stylesheets never get the stringvalue of a bool so that won't
+ // really buy us anything.
+ return nullptr;
+}
+
+bool BooleanResult::booleanValue() { return this->value; } //-- toBoolean
+
+double BooleanResult::numberValue() {
+ return (value) ? 1.0 : 0.0;
+} //-- toNumber
diff --git a/dom/xslt/xpath/txCoreFunctionCall.cpp b/dom/xslt/xpath/txCoreFunctionCall.cpp
new file mode 100644
index 0000000000..6e2285ed18
--- /dev/null
+++ b/dom/xslt/xpath/txCoreFunctionCall.cpp
@@ -0,0 +1,665 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/FloatingPoint.h"
+
+#include "txExpr.h"
+#include "txNodeSet.h"
+#include "nsGkAtoms.h"
+#include "txIXPathContext.h"
+#include "nsWhitespaceTokenizer.h"
+#include "txXPathTreeWalker.h"
+#include <math.h>
+#include "txStringUtils.h"
+#include "txXMLUtils.h"
+
+using namespace mozilla;
+
+struct txCoreFunctionDescriptor {
+ const int8_t mMinParams;
+ const int8_t mMaxParams;
+ const Expr::ResultType mReturnType;
+ const nsStaticAtom* const mName;
+};
+
+// This must be ordered in the same order as txCoreFunctionCall::eType.
+// If you change one, change the other.
+static const txCoreFunctionDescriptor descriptTable[] = {
+ {1, 1, Expr::NUMBER_RESULT, nsGkAtoms::count}, // COUNT
+ {1, 1, Expr::NODESET_RESULT, nsGkAtoms::id}, // ID
+ {0, 0, Expr::NUMBER_RESULT, nsGkAtoms::last}, // LAST
+ {0, 1, Expr::STRING_RESULT, nsGkAtoms::localName}, // LOCAL_NAME
+ {0, 1, Expr::STRING_RESULT, nsGkAtoms::namespaceUri}, // NAMESPACE_URI
+ {0, 1, Expr::STRING_RESULT, nsGkAtoms::name}, // NAME
+ {0, 0, Expr::NUMBER_RESULT, nsGkAtoms::position}, // POSITION
+
+ {2, -1, Expr::STRING_RESULT, nsGkAtoms::concat}, // CONCAT
+ {2, 2, Expr::BOOLEAN_RESULT, nsGkAtoms::contains}, // CONTAINS
+ {0, 1, Expr::STRING_RESULT, nsGkAtoms::normalizeSpace}, // NORMALIZE_SPACE
+ {2, 2, Expr::BOOLEAN_RESULT, nsGkAtoms::startsWith}, // STARTS_WITH
+ {0, 1, Expr::STRING_RESULT, nsGkAtoms::string}, // STRING
+ {0, 1, Expr::NUMBER_RESULT, nsGkAtoms::stringLength}, // STRING_LENGTH
+ {2, 3, Expr::STRING_RESULT, nsGkAtoms::substring}, // SUBSTRING
+ {2, 2, Expr::STRING_RESULT, nsGkAtoms::substringAfter}, // SUBSTRING_AFTER
+ {2, 2, Expr::STRING_RESULT,
+ nsGkAtoms::substringBefore}, // SUBSTRING_BEFORE
+ {3, 3, Expr::STRING_RESULT, nsGkAtoms::translate}, // TRANSLATE
+
+ {0, 1, Expr::NUMBER_RESULT, nsGkAtoms::number}, // NUMBER
+ {1, 1, Expr::NUMBER_RESULT, nsGkAtoms::round}, // ROUND
+ {1, 1, Expr::NUMBER_RESULT, nsGkAtoms::floor}, // FLOOR
+ {1, 1, Expr::NUMBER_RESULT, nsGkAtoms::ceiling}, // CEILING
+ {1, 1, Expr::NUMBER_RESULT, nsGkAtoms::sum}, // SUM
+
+ {1, 1, Expr::BOOLEAN_RESULT, nsGkAtoms::boolean}, // BOOLEAN
+ {0, 0, Expr::BOOLEAN_RESULT, nsGkAtoms::_false}, // _FALSE
+ {1, 1, Expr::BOOLEAN_RESULT, nsGkAtoms::lang}, // LANG
+ {1, 1, Expr::BOOLEAN_RESULT, nsGkAtoms::_not}, // _NOT
+ {0, 0, Expr::BOOLEAN_RESULT, nsGkAtoms::_true} // _TRUE
+};
+
+/*
+ * 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 = nullptr;
+
+ if (!requireParams(descriptTable[mType].mMinParams,
+ descriptTable[mType].mMaxParams, aContext)) {
+ return NS_ERROR_XPATH_BAD_ARGUMENT_COUNT;
+ }
+
+ nsresult rv = NS_OK;
+ switch (mType) {
+ case COUNT: {
+ RefPtr<txNodeSet> nodes;
+ rv = evaluateToNodeSet(mParams[0], aContext, getter_AddRefs(nodes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ return aContext->recycler()->getNumberResult(nodes->size(), aResult);
+ }
+ case ID: {
+ RefPtr<txAExprResult> exprResult;
+ rv = mParams[0]->evaluate(aContext, getter_AddRefs(exprResult));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ RefPtr<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));
+ int32_t 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
+ RefPtr<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 = nullptr;
+ 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 = nullptr;
+ 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 = nullptr;
+ 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: {
+ MOZ_CRASH("Unexpected mType?!");
+ }
+ }
+ MOZ_CRASH("Inner mType switch should have returned!");
+ }
+ case POSITION: {
+ return aContext->recycler()->getNumberResult(aContext->position(),
+ aResult);
+ }
+
+ // String functions
+
+ case CONCAT: {
+ RefPtr<StringResult> strRes;
+ rv = aContext->recycler()->getStringResult(getter_AddRefs(strRes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ uint32_t 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(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);
+ }
+
+ RefPtr<StringResult> strRes;
+ rv = aContext->recycler()->getStringResult(getter_AddRefs(strRes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ bool addSpace = false;
+ bool first = true;
+ strRes->mValue.SetCapacity(resultStr.Length());
+ char16_t c;
+ uint32_t src;
+ for (src = 0; src < resultStr.Length(); src++) {
+ c = resultStr.CharAt(src);
+ if (XMLUtils::isWhitespace(c)) {
+ addSpace = true;
+ } else {
+ if (addSpace && !first) strRes->mValue.Append(char16_t(' '));
+
+ strRes->mValue.Append(c);
+ addSpace = false;
+ first = 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);
+
+ bool result = false;
+ if (arg2.IsEmpty()) {
+ result = 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: {
+ RefPtr<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 (std::isnan(start) || std::isinf(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 (std::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, (uint32_t)start, (uint32_t)(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);
+ }
+
+ int32_t idx = arg1.Find(arg2);
+ if (idx == kNotFound) {
+ aContext->recycler()->getEmptyStringResult(aResult);
+
+ return NS_OK;
+ }
+
+ const nsAString& 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);
+
+ int32_t 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;
+ }
+
+ RefPtr<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);
+
+ uint32_t i;
+ int32_t newCharsLength = (int32_t)newChars.Length();
+ for (i = 0; i < src.Length(); i++) {
+ int32_t idx = oldChars.FindChar(src.CharAt(i));
+ if (idx != kNotFound) {
+ if (idx < newCharsLength)
+ strRes->mValue.Append(newChars.CharAt((uint32_t)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 = txDouble::toDouble(resultStr);
+ }
+ return aContext->recycler()->getNumberResult(res, aResult);
+ }
+ case ROUND: {
+ double dbl;
+ rv = evaluateToNumber(mParams[0], aContext, &dbl);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (std::isfinite(dbl)) {
+ if (mozilla::IsNegative(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 (std::isfinite(dbl) && !mozilla::IsNegativeZero(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 (std::isfinite(dbl)) {
+ if (mozilla::IsNegative(dbl) && dbl > -1)
+ dbl *= 0;
+ else
+ dbl = ceil(dbl);
+ }
+
+ return aContext->recycler()->getNumberResult(dbl, aResult);
+ }
+ case SUM: {
+ RefPtr<txNodeSet> nodes;
+ nsresult rv =
+ evaluateToNodeSet(mParams[0], aContext, getter_AddRefs(nodes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ double res = 0;
+ int32_t i;
+ for (i = 0; i < nodes->size(); ++i) {
+ nsAutoString resultStr;
+ txXPathNodeUtils::appendNodeValue(nodes->get(i), resultStr);
+ res += txDouble::toDouble(resultStr);
+ }
+ return aContext->recycler()->getNumberResult(res, aResult);
+ }
+
+ // Boolean functions
+
+ case BOOLEAN: {
+ bool 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(false, aResult);
+
+ return NS_OK;
+ }
+ case LANG: {
+ txXPathTreeWalker walker(aContext->getContextNode());
+
+ nsAutoString lang;
+ bool found;
+ do {
+ found = walker.getAttr(nsGkAtoms::lang, kNameSpaceID_XML, lang);
+ } while (!found && walker.moveToParent());
+
+ if (!found) {
+ aContext->recycler()->getBoolResult(false, aResult);
+
+ return NS_OK;
+ }
+
+ nsAutoString arg;
+ rv = mParams[0]->evaluateToString(aContext, arg);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ bool result =
+ StringBeginsWith(lang, arg, nsCaseInsensitiveStringComparator) &&
+ (lang.Length() == arg.Length() || lang.CharAt(arg.Length()) == '-');
+
+ aContext->recycler()->getBoolResult(result, aResult);
+
+ return NS_OK;
+ }
+ case _NOT: {
+ bool 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(true, aResult);
+
+ return NS_OK;
+ }
+ }
+
+ aContext->receiveError(u"Internal error"_ns, NS_ERROR_UNEXPECTED);
+ return NS_ERROR_UNEXPECTED;
+}
+
+Expr::ResultType txCoreFunctionCall::getReturnType() {
+ return descriptTable[mType].mReturnType;
+}
+
+bool txCoreFunctionCall::isSensitiveTo(ContextSensitivity aContext) {
+ switch (mType) {
+ case COUNT:
+ case CONCAT:
+ case CONTAINS:
+ case STARTS_WITH:
+ case SUBSTRING:
+ case SUBSTRING_AFTER:
+ case SUBSTRING_BEFORE:
+ case TRANSLATE:
+ case ROUND:
+ case FLOOR:
+ case CEILING:
+ case SUM:
+ case BOOLEAN:
+ case _NOT:
+ case _FALSE:
+ case _TRUE: {
+ return argsSensitiveTo(aContext);
+ }
+ case ID: {
+ return (aContext & NODE_CONTEXT) || argsSensitiveTo(aContext);
+ }
+ case LAST: {
+ return !!(aContext & SIZE_CONTEXT);
+ }
+ case LOCAL_NAME:
+ case NAME:
+ case NAMESPACE_URI:
+ case NORMALIZE_SPACE:
+ case STRING:
+ case STRING_LENGTH:
+ case NUMBER: {
+ if (mParams.IsEmpty()) {
+ return !!(aContext & NODE_CONTEXT);
+ }
+ return argsSensitiveTo(aContext);
+ }
+ case POSITION: {
+ return !!(aContext & POSITION_CONTEXT);
+ }
+ case LANG: {
+ return (aContext & NODE_CONTEXT) || argsSensitiveTo(aContext);
+ }
+ }
+
+ MOZ_ASSERT_UNREACHABLE("how'd we get here?");
+ return true;
+}
+
+// static
+bool txCoreFunctionCall::getTypeFromAtom(nsAtom* aName, eType& aType) {
+ uint32_t i;
+ for (i = 0; i < ArrayLength(descriptTable); ++i) {
+ if (aName == descriptTable[i].mName) {
+ aType = static_cast<eType>(i);
+
+ return true;
+ }
+ }
+
+ return false;
+}
+
+#ifdef TX_TO_STRING
+void txCoreFunctionCall::appendName(nsAString& aDest) {
+ aDest.Append(descriptTable[mType].mName->GetUTF16String());
+}
+#endif
diff --git a/dom/xslt/xpath/txErrorExpr.cpp b/dom/xslt/xpath/txErrorExpr.cpp
new file mode 100644
index 0000000000..806b324259
--- /dev/null
+++ b/dom/xslt/xpath/txErrorExpr.cpp
@@ -0,0 +1,35 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsError.h"
+#include "txExpr.h"
+#include "nsString.h"
+#include "txIXPathContext.h"
+
+nsresult txErrorExpr::evaluate(txIEvalContext* aContext,
+ txAExprResult** aResult) {
+ *aResult = nullptr;
+
+ nsAutoString err(u"Invalid expression evaluated"_ns);
+#ifdef TX_TO_STRING
+ err.AppendLiteral(": ");
+ toString(err);
+#endif
+ aContext->receiveError(err, NS_ERROR_XPATH_INVALID_EXPRESSION_EVALUATED);
+
+ return NS_ERROR_XPATH_INVALID_EXPRESSION_EVALUATED;
+}
+
+TX_IMPL_EXPR_STUBS_0(txErrorExpr, ANY_RESULT)
+
+bool txErrorExpr::isSensitiveTo(ContextSensitivity aContext) {
+ // It doesn't really matter what we return here, but it might
+ // be a good idea to try to keep this as unoptimizable as possible
+ return true;
+}
+
+#ifdef TX_TO_STRING
+void txErrorExpr::toString(nsAString& aStr) { aStr.Append(mStr); }
+#endif
diff --git a/dom/xslt/xpath/txExpr.cpp b/dom/xslt/xpath/txExpr.cpp
new file mode 100644
index 0000000000..d5ea774f62
--- /dev/null
+++ b/dom/xslt/xpath/txExpr.cpp
@@ -0,0 +1,26 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txExpr.h"
+
+nsresult Expr::evaluateToBool(txIEvalContext* aContext, bool& aResult) {
+ RefPtr<txAExprResult> exprRes;
+ nsresult rv = evaluate(aContext, getter_AddRefs(exprRes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aResult = exprRes->booleanValue();
+
+ return NS_OK;
+}
+
+nsresult Expr::evaluateToString(txIEvalContext* aContext, nsString& aResult) {
+ RefPtr<txAExprResult> exprRes;
+ nsresult rv = evaluate(aContext, getter_AddRefs(exprRes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ exprRes->stringValue(aResult);
+
+ return NS_OK;
+}
diff --git a/dom/xslt/xpath/txExpr.h b/dom/xslt/xpath/txExpr.h
new file mode 100644
index 0000000000..2622a3fe9f
--- /dev/null
+++ b/dom/xslt/xpath/txExpr.h
@@ -0,0 +1,847 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef TRANSFRMX_EXPR_H
+#define TRANSFRMX_EXPR_H
+
+#include "mozilla/Attributes.h"
+#include "mozilla/UniquePtr.h"
+#include "txExprResult.h"
+#include "txCore.h"
+#include "nsString.h"
+#include "txOwningArray.h"
+#include "nsAtom.h"
+
+#ifdef DEBUG
+# define TX_TO_STRING
+#endif
+
+/*
+ XPath class definitions.
+ Much of this code was ported from XSL:P.
+*/
+
+class nsAtom;
+class txIMatchContext;
+class txIEvalContext;
+class txNodeSet;
+class txXPathNode;
+class txXPathTreeWalker;
+
+/**
+ * A Base Class for all XSL Expressions
+ **/
+class Expr {
+ public:
+ MOZ_COUNTED_DEFAULT_CTOR(Expr)
+ MOZ_COUNTED_DTOR_VIRTUAL(Expr)
+
+ /**
+ * 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
+ **/
+ virtual nsresult evaluate(txIEvalContext* aContext,
+ txAExprResult** aResult) = 0;
+
+ /**
+ * Returns the type of this expression.
+ */
+ enum ExprType {
+ LOCATIONSTEP_EXPR,
+ PATH_EXPR,
+ UNION_EXPR,
+ LITERAL_EXPR,
+ OTHER_EXPR
+ };
+ virtual ExprType getType() { return OTHER_EXPR; }
+
+ /**
+ * Returns the type or types of results this Expr return.
+ */
+ using ResultType = uint16_t;
+ enum {
+ NODESET_RESULT = 0x01,
+ BOOLEAN_RESULT = 0x02,
+ NUMBER_RESULT = 0x04,
+ STRING_RESULT = 0x08,
+ RTF_RESULT = 0x10,
+ ANY_RESULT = 0xFFFF
+ };
+ virtual ResultType getReturnType() = 0;
+ bool canReturnType(ResultType aType) {
+ return (getReturnType() & aType) != 0;
+ }
+
+ using ContextSensitivity = uint16_t;
+ enum {
+ NO_CONTEXT = 0x00,
+ NODE_CONTEXT = 0x01,
+ POSITION_CONTEXT = 0x02,
+ SIZE_CONTEXT = 0x04,
+ NODESET_CONTEXT = POSITION_CONTEXT | SIZE_CONTEXT,
+ VARIABLES_CONTEXT = 0x08,
+ PRIVATE_CONTEXT = 0x10,
+ ANY_CONTEXT = 0xFFFF
+ };
+
+ /**
+ * Returns true if this expression is sensitive to *any* of
+ * the requested contexts in aContexts.
+ */
+ virtual bool isSensitiveTo(ContextSensitivity aContexts) = 0;
+
+ /**
+ * Returns sub-expression at given position
+ */
+ virtual Expr* getSubExprAt(uint32_t aPos) = 0;
+
+ /**
+ * Replace sub-expression at given position. Does not delete the old
+ * expression, that is the responsibility of the caller.
+ */
+ virtual void setSubExprAt(uint32_t aPos, Expr* aExpr) = 0;
+
+ virtual nsresult evaluateToBool(txIEvalContext* aContext, bool& aResult);
+
+ virtual nsresult evaluateToString(txIEvalContext* aContext,
+ nsString& aResult);
+
+#ifdef TX_TO_STRING
+ /**
+ * Returns the String representation of this Expr.
+ * @param dest the String to use when creating the String
+ * representation. The String representation will be appended to
+ * any data in the destination String, to allow cascading calls to
+ * other #toString() methods for Expressions.
+ * @return the String representation of this Expr.
+ **/
+ virtual void toString(nsAString& str) = 0;
+#endif
+}; //-- Expr
+
+#ifdef TX_TO_STRING
+# define TX_DECL_TOSTRING void toString(nsAString& aDest) override;
+# define TX_DECL_APPENDNAME void appendName(nsAString& aDest) override;
+#else
+# define TX_DECL_TOSTRING
+# define TX_DECL_APPENDNAME
+#endif
+
+#define TX_DECL_EXPR_BASE \
+ nsresult evaluate(txIEvalContext* aContext, txAExprResult** aResult) \
+ override; \
+ ResultType getReturnType() override; \
+ bool isSensitiveTo(ContextSensitivity aContexts) override;
+
+#define TX_DECL_EXPR \
+ TX_DECL_EXPR_BASE \
+ TX_DECL_TOSTRING \
+ Expr* getSubExprAt(uint32_t aPos) override; \
+ void setSubExprAt(uint32_t aPos, Expr* aExpr) override;
+
+#define TX_DECL_OPTIMIZABLE_EXPR \
+ TX_DECL_EXPR \
+ ExprType getType() override;
+
+#define TX_DECL_FUNCTION \
+ TX_DECL_APPENDNAME \
+ TX_DECL_EXPR_BASE
+
+#define TX_IMPL_EXPR_STUBS_BASE(_class, _ReturnType) \
+ Expr::ResultType _class::getReturnType() { return _ReturnType; }
+
+#define TX_IMPL_EXPR_STUBS_0(_class, _ReturnType) \
+ TX_IMPL_EXPR_STUBS_BASE(_class, _ReturnType) \
+ Expr* _class::getSubExprAt(uint32_t aPos) { return nullptr; } \
+ void _class::setSubExprAt(uint32_t aPos, Expr* aExpr) { \
+ MOZ_ASSERT_UNREACHABLE("setting bad subexpression index"); \
+ }
+
+#define TX_IMPL_EXPR_STUBS_1(_class, _ReturnType, _Expr1) \
+ TX_IMPL_EXPR_STUBS_BASE(_class, _ReturnType) \
+ Expr* _class::getSubExprAt(uint32_t aPos) { \
+ if (aPos == 0) { \
+ return _Expr1.get(); \
+ } \
+ return nullptr; \
+ } \
+ void _class::setSubExprAt(uint32_t aPos, Expr* aExpr) { \
+ NS_ASSERTION(aPos < 1, "setting bad subexpression index"); \
+ mozilla::Unused << _Expr1.release(); \
+ _Expr1 = mozilla::WrapUnique(aExpr); \
+ }
+
+#define TX_IMPL_EXPR_STUBS_2(_class, _ReturnType, _Expr1, _Expr2) \
+ TX_IMPL_EXPR_STUBS_BASE(_class, _ReturnType) \
+ Expr* _class::getSubExprAt(uint32_t aPos) { \
+ switch (aPos) { \
+ case 0: \
+ return _Expr1.get(); \
+ case 1: \
+ return _Expr2.get(); \
+ default: \
+ break; \
+ } \
+ return nullptr; \
+ } \
+ void _class::setSubExprAt(uint32_t aPos, Expr* aExpr) { \
+ NS_ASSERTION(aPos < 2, "setting bad subexpression index"); \
+ if (aPos == 0) { \
+ mozilla::Unused << _Expr1.release(); \
+ _Expr1 = mozilla::WrapUnique(aExpr); \
+ } else { \
+ mozilla::Unused << _Expr2.release(); \
+ _Expr2 = mozilla::WrapUnique(aExpr); \
+ } \
+ }
+
+#define TX_IMPL_EXPR_STUBS_LIST(_class, _ReturnType, _ExprList) \
+ TX_IMPL_EXPR_STUBS_BASE(_class, _ReturnType) \
+ Expr* _class::getSubExprAt(uint32_t aPos) { \
+ return _ExprList.SafeElementAt(aPos); \
+ } \
+ void _class::setSubExprAt(uint32_t aPos, Expr* aExpr) { \
+ NS_ASSERTION(aPos < _ExprList.Length(), \
+ "setting bad subexpression index"); \
+ _ExprList[aPos] = aExpr; \
+ }
+
+/**
+ * This class represents a FunctionCall as defined by the XPath 1.0
+ * Recommendation.
+ **/
+class FunctionCall : public Expr {
+ public:
+ /**
+ * Adds the given parameter to this FunctionCall's parameter list.
+ * The ownership of the given Expr is passed over to the FunctionCall,
+ * even on failure.
+ * @param aExpr the Expr to add to this FunctionCall's parameter list
+ */
+ void addParam(Expr* aExpr) { mParams.AppendElement(aExpr); }
+
+ /**
+ * Check if the number of parameters falls within a range.
+ *
+ * @param aParamCountMin minimum number of required parameters.
+ * @param aParamCountMax maximum number of parameters. If aParamCountMax
+ * is negative the maximum number is not checked.
+ * @return boolean representing whether the number of parameters falls
+ * within the expected range or not.
+ *
+ * XXX txIEvalContext should be txIParseContest, bug 143291
+ */
+ virtual bool requireParams(int32_t aParamCountMin, int32_t aParamCountMax,
+ txIEvalContext* aContext);
+
+ TX_DECL_TOSTRING
+ Expr* getSubExprAt(uint32_t aPos) override;
+ void setSubExprAt(uint32_t aPos, Expr* aExpr) override;
+
+ protected:
+ txOwningArray<Expr> mParams;
+
+ /*
+ * Evaluates the given Expression and converts its result to a number.
+ */
+ static nsresult evaluateToNumber(Expr* aExpr, txIEvalContext* aContext,
+ double* aResult);
+
+ /*
+ * Evaluates the given Expression and converts its result to a NodeSet.
+ * If the result is not a NodeSet an error is returned.
+ */
+ static nsresult evaluateToNodeSet(Expr* aExpr, txIEvalContext* aContext,
+ txNodeSet** aResult);
+
+ /**
+ * Returns true if any argument is sensitive to the given context.
+ */
+ bool argsSensitiveTo(ContextSensitivity aContexts);
+
+#ifdef TX_TO_STRING
+ /*
+ * Appends the name of the function to `aStr`.
+ */
+ virtual void appendName(nsAString& aStr) = 0;
+#endif
+};
+
+class txCoreFunctionCall : public FunctionCall {
+ public:
+ // This must be ordered in the same order as descriptTable in
+ // txCoreFunctionCall.cpp. If you change one, change the other.
+ enum eType {
+ COUNT = 0, // count()
+ ID, // id()
+ LAST, // last()
+ LOCAL_NAME, // local-name()
+ NAMESPACE_URI, // namespace-uri()
+ NAME, // name()
+ POSITION, // position()
+
+ CONCAT, // concat()
+ CONTAINS, // contains()
+ NORMALIZE_SPACE, // normalize-space()
+ STARTS_WITH, // starts-with()
+ STRING, // string()
+ STRING_LENGTH, // string-length()
+ SUBSTRING, // substring()
+ SUBSTRING_AFTER, // substring-after()
+ SUBSTRING_BEFORE, // substring-before()
+ TRANSLATE, // translate()
+
+ NUMBER, // number()
+ ROUND, // round()
+ FLOOR, // floor()
+ CEILING, // ceiling()
+ SUM, // sum()
+
+ BOOLEAN, // boolean()
+ _FALSE, // false()
+ LANG, // lang()
+ _NOT, // not()
+ _TRUE // true()
+ };
+
+ /*
+ * Creates a txCoreFunctionCall of the given type
+ */
+ explicit txCoreFunctionCall(eType aType) : mType(aType) {}
+
+ TX_DECL_FUNCTION
+
+ static bool getTypeFromAtom(nsAtom* aName, eType& aType);
+
+ private:
+ eType mType;
+};
+
+/*
+ * This class represents a NodeTest as defined by the XPath spec
+ */
+class txNodeTest {
+ public:
+ MOZ_COUNTED_DEFAULT_CTOR(txNodeTest)
+ MOZ_COUNTED_DTOR_VIRTUAL(txNodeTest)
+
+ /*
+ * Virtual methods
+ * pretty much a txPattern, but not supposed to be used
+ * standalone. The NodeTest node() is different to the
+ * Pattern "node()" (document node isn't matched)
+ */
+ virtual nsresult matches(const txXPathNode& aNode, txIMatchContext* aContext,
+ bool& aMatched) = 0;
+ virtual double getDefaultPriority() = 0;
+
+ /**
+ * Returns the type of this nodetest.
+ */
+ enum NodeTestType { NAME_TEST, NODETYPE_TEST, OTHER_TEST };
+ virtual NodeTestType getType() { return OTHER_TEST; }
+
+ /**
+ * Returns true if this expression is sensitive to *any* of
+ * the requested flags.
+ */
+ virtual bool isSensitiveTo(Expr::ContextSensitivity aContext) = 0;
+
+#ifdef TX_TO_STRING
+ virtual void toString(nsAString& aDest) = 0;
+#endif
+};
+
+#define TX_DECL_NODE_TEST \
+ TX_DECL_TOSTRING \
+ nsresult matches(const txXPathNode& aNode, txIMatchContext* aContext, \
+ bool& aMatched) override; \
+ double getDefaultPriority() override; \
+ bool isSensitiveTo(Expr::ContextSensitivity aContext) override;
+
+/*
+ * This class represents a NameTest as defined by the XPath spec
+ */
+class txNameTest : public txNodeTest {
+ public:
+ /*
+ * Creates a new txNameTest with the given type and the given
+ * principal node type
+ */
+ txNameTest(nsAtom* aPrefix, nsAtom* aLocalName, int32_t aNSID,
+ uint16_t aNodeType);
+
+ NodeTestType getType() override;
+
+ TX_DECL_NODE_TEST
+
+ RefPtr<nsAtom> mPrefix;
+ RefPtr<nsAtom> mLocalName;
+ int32_t mNamespace;
+
+ private:
+ uint16_t mNodeType;
+};
+
+/*
+ * This class represents a NodeType as defined by the XPath spec
+ */
+class txNodeTypeTest : public txNodeTest {
+ public:
+ enum NodeType { COMMENT_TYPE, TEXT_TYPE, PI_TYPE, NODE_TYPE };
+
+ /*
+ * Creates a new txNodeTypeTest of the given type
+ */
+ explicit txNodeTypeTest(NodeType aNodeType) : mNodeType(aNodeType) {}
+
+ /*
+ * Sets the name of the node to match. Only availible for pi nodes
+ */
+ void setNodeName(const nsAString& aName) { mNodeName = NS_Atomize(aName); }
+
+ NodeType getNodeTestType() { return mNodeType; }
+
+ NodeTestType getType() override;
+
+ TX_DECL_NODE_TEST
+
+ private:
+ NodeType mNodeType;
+ RefPtr<nsAtom> mNodeName;
+};
+
+/**
+ * Class representing a nodetest combined with a predicate. May only be used
+ * if the predicate is not sensitive to the context-nodelist.
+ */
+class txPredicatedNodeTest : public txNodeTest {
+ public:
+ txPredicatedNodeTest(txNodeTest* aNodeTest, Expr* aPredicate);
+ TX_DECL_NODE_TEST
+
+ private:
+ mozilla::UniquePtr<txNodeTest> mNodeTest;
+ mozilla::UniquePtr<Expr> mPredicate;
+};
+
+/**
+ * Represents an ordered list of Predicates,
+ * for use with Step and Filter Expressions
+ **/
+class PredicateList {
+ public:
+ /**
+ * Adds the given Expr to the list.
+ * The ownership of the given Expr is passed over the PredicateList,
+ * even on failure.
+ * @param aExpr the Expr to add to the list
+ */
+ void add(Expr* aExpr) {
+ NS_ASSERTION(aExpr, "missing expression");
+ mPredicates.AppendElement(aExpr);
+ }
+
+ nsresult evaluatePredicates(txNodeSet* aNodes, txIMatchContext* aContext);
+
+ /**
+ * Drops the first predicate without deleting it.
+ */
+ void dropFirst() { mPredicates.RemoveElementAt(0); }
+
+ /**
+ * returns true if this predicate list is empty
+ **/
+ bool isEmpty() { return mPredicates.IsEmpty(); }
+
+#ifdef TX_TO_STRING
+ /**
+ * Returns the String representation of this PredicateList.
+ * @param dest the String to use when creating the String
+ * representation. The String representation will be appended to
+ * any data in the destination String, to allow cascading calls to
+ * other #toString() methods for Expressions.
+ * @return the String representation of this PredicateList.
+ **/
+ void toString(nsAString& dest);
+#endif
+
+ protected:
+ bool isSensitiveTo(Expr::ContextSensitivity aContext);
+ Expr* getSubExprAt(uint32_t aPos) { return mPredicates.SafeElementAt(aPos); }
+ void setSubExprAt(uint32_t aPos, Expr* aExpr) {
+ NS_ASSERTION(aPos < mPredicates.Length(),
+ "setting bad subexpression index");
+ mPredicates[aPos] = aExpr;
+ }
+
+ //-- list of predicates
+ txOwningArray<Expr> mPredicates;
+}; //-- PredicateList
+
+class LocationStep : public Expr, public PredicateList {
+ public:
+ enum LocationStepType {
+ ANCESTOR_AXIS = 0,
+ ANCESTOR_OR_SELF_AXIS,
+ ATTRIBUTE_AXIS,
+ CHILD_AXIS,
+ DESCENDANT_AXIS,
+ DESCENDANT_OR_SELF_AXIS,
+ FOLLOWING_AXIS,
+ FOLLOWING_SIBLING_AXIS,
+ NAMESPACE_AXIS,
+ PARENT_AXIS,
+ PRECEDING_AXIS,
+ PRECEDING_SIBLING_AXIS,
+ SELF_AXIS
+ };
+
+ /**
+ * Creates a new LocationStep using the given NodeExpr and Axis Identifier
+ * @param nodeExpr the NodeExpr to use when matching Nodes
+ * @param axisIdentifier the Axis Identifier in which to search for nodes
+ **/
+ LocationStep(txNodeTest* aNodeTest, LocationStepType aAxisIdentifier)
+ : mNodeTest(aNodeTest), mAxisIdentifier(aAxisIdentifier) {}
+
+ TX_DECL_OPTIMIZABLE_EXPR
+
+ txNodeTest* getNodeTest() { return mNodeTest.get(); }
+ void setNodeTest(txNodeTest* aNodeTest) {
+ mozilla::Unused << mNodeTest.release();
+ mNodeTest = mozilla::WrapUnique(aNodeTest);
+ }
+ LocationStepType getAxisIdentifier() { return mAxisIdentifier; }
+ void setAxisIdentifier(LocationStepType aAxisIdentifier) {
+ mAxisIdentifier = aAxisIdentifier;
+ }
+
+ private:
+ /**
+ * Append the current position of aWalker to aNodes if it matches mNodeTest,
+ * using aContext as the context for matching.
+ */
+ nsresult appendIfMatching(const txXPathTreeWalker& aWalker,
+ txIMatchContext* aContext, txNodeSet* aNodes);
+
+ /**
+ * Append the descendants of the current position of aWalker to aNodes if
+ * they match mNodeTest, using aContext as the context for matching.
+ */
+ nsresult appendMatchingDescendants(const txXPathTreeWalker& aWalker,
+ txIMatchContext* aContext,
+ txNodeSet* aNodes);
+
+ /**
+ * Append the descendants of the current position of aWalker to aNodes in
+ * reverse order if they match mNodeTest, using aContext as the context for
+ * matching.
+ */
+ nsresult appendMatchingDescendantsRev(const txXPathTreeWalker& aWalker,
+ txIMatchContext* aContext,
+ txNodeSet* aNodes);
+
+ mozilla::UniquePtr<txNodeTest> mNodeTest;
+ LocationStepType mAxisIdentifier;
+};
+
+class FilterExpr : public Expr, public PredicateList {
+ public:
+ /**
+ * Creates a new FilterExpr using the given Expr
+ * @param expr the Expr to use for evaluation
+ */
+ explicit FilterExpr(Expr* aExpr) : expr(aExpr) {}
+
+ TX_DECL_EXPR
+
+ private:
+ mozilla::UniquePtr<Expr> expr;
+
+}; //-- FilterExpr
+
+class txLiteralExpr : public Expr {
+ public:
+ explicit txLiteralExpr(double aDbl)
+ : mValue(new NumberResult(aDbl, nullptr)) {}
+ explicit txLiteralExpr(const nsAString& aStr)
+ : mValue(new StringResult(aStr, nullptr)) {}
+ explicit txLiteralExpr(txAExprResult* aValue) : mValue(aValue) {}
+
+ TX_DECL_EXPR
+
+ private:
+ RefPtr<txAExprResult> mValue;
+};
+
+/**
+ * Represents an UnaryExpr. Returns the negative value of its expr.
+ **/
+class UnaryExpr : public Expr {
+ public:
+ explicit UnaryExpr(Expr* aExpr) : expr(aExpr) {}
+
+ TX_DECL_EXPR
+
+ private:
+ mozilla::UniquePtr<Expr> expr;
+}; //-- UnaryExpr
+
+/**
+ * Represents a BooleanExpr, a binary expression that
+ * performs a boolean operation between its lvalue and rvalue.
+ **/
+class BooleanExpr : public Expr {
+ public:
+ //-- BooleanExpr Types
+ enum _BooleanExprType { AND = 1, OR };
+
+ BooleanExpr(Expr* aLeftExpr, Expr* aRightExpr, short aOp)
+ : leftExpr(aLeftExpr), rightExpr(aRightExpr), op(aOp) {}
+
+ TX_DECL_EXPR
+
+ private:
+ mozilla::UniquePtr<Expr> leftExpr, rightExpr;
+ short op;
+}; //-- BooleanExpr
+
+/**
+ * Represents a MultiplicativeExpr, a binary expression that
+ * performs a multiplicative operation between its lvalue and rvalue:
+ * * : multiply
+ * mod : modulus
+ * div : divide
+ *
+ **/
+class txNumberExpr : public Expr {
+ public:
+ enum eOp { ADD, SUBTRACT, DIVIDE, MULTIPLY, MODULUS };
+
+ txNumberExpr(Expr* aLeftExpr, Expr* aRightExpr, eOp aOp)
+ : mLeftExpr(aLeftExpr), mRightExpr(aRightExpr), mOp(aOp) {}
+
+ TX_DECL_EXPR
+
+ private:
+ mozilla::UniquePtr<Expr> mLeftExpr, mRightExpr;
+ eOp mOp;
+}; //-- MultiplicativeExpr
+
+/**
+ * Represents a RelationalExpr, an expression that compares its lvalue
+ * to its rvalue using:
+ * = : equal to
+ * < : less than
+ * > : greater than
+ * <= : less than or equal to
+ * >= : greater than or equal to
+ *
+ **/
+class RelationalExpr : public Expr {
+ public:
+ enum RelationalExprType {
+ EQUAL,
+ NOT_EQUAL,
+ LESS_THAN,
+ GREATER_THAN,
+ LESS_OR_EQUAL,
+ GREATER_OR_EQUAL
+ };
+
+ RelationalExpr(Expr* aLeftExpr, Expr* aRightExpr, RelationalExprType aOp)
+ : mLeftExpr(aLeftExpr), mRightExpr(aRightExpr), mOp(aOp) {}
+
+ TX_DECL_EXPR
+
+ private:
+ bool compareResults(txIEvalContext* aContext, txAExprResult* aLeft,
+ txAExprResult* aRight);
+
+ mozilla::UniquePtr<Expr> mLeftExpr;
+ mozilla::UniquePtr<Expr> mRightExpr;
+ RelationalExprType mOp;
+};
+
+/**
+ * VariableRefExpr
+ * Represents a variable reference ($refname)
+ **/
+class VariableRefExpr : public Expr {
+ public:
+ VariableRefExpr(nsAtom* aPrefix, nsAtom* aLocalName, int32_t aNSID);
+
+ TX_DECL_EXPR
+
+ private:
+ RefPtr<nsAtom> mPrefix;
+ RefPtr<nsAtom> mLocalName;
+ int32_t mNamespace;
+};
+
+/**
+ * Represents a PathExpr
+ **/
+class PathExpr : public Expr {
+ public:
+ //-- Path Operators
+ //-- RELATIVE_OP is the default
+ //-- LF, changed from static const short to enum
+ enum PathOperator { RELATIVE_OP, DESCENDANT_OP };
+
+ /**
+ * Adds the Expr to this PathExpr
+ * The ownership of the given Expr is passed over the PathExpr,
+ * even on failure.
+ * @param aExpr the Expr to add to this PathExpr
+ */
+ void addExpr(Expr* aExpr, PathOperator pathOp);
+
+ /**
+ * Removes and deletes the expression at the given index.
+ */
+ void deleteExprAt(uint32_t aPos) {
+ NS_ASSERTION(aPos < mItems.Length(), "killing bad expression index");
+ mItems.RemoveElementAt(aPos);
+ }
+
+ TX_DECL_OPTIMIZABLE_EXPR
+
+ PathOperator getPathOpAt(uint32_t aPos) {
+ NS_ASSERTION(aPos < mItems.Length(), "getting bad pathop index");
+ return mItems[aPos].pathOp;
+ }
+ void setPathOpAt(uint32_t aPos, PathOperator aPathOp) {
+ NS_ASSERTION(aPos < mItems.Length(), "setting bad pathop index");
+ mItems[aPos].pathOp = aPathOp;
+ }
+
+ private:
+ class PathExprItem {
+ public:
+ mozilla::UniquePtr<Expr> expr;
+ PathOperator pathOp;
+ };
+
+ nsTArray<PathExprItem> mItems;
+
+ /*
+ * Selects from the descendants of the context node
+ * all nodes that match the Expr
+ */
+ nsresult evalDescendants(Expr* aStep, const txXPathNode& aNode,
+ txIMatchContext* aContext, txNodeSet* resNodes);
+};
+
+/**
+ * This class represents a RootExpr, which only matches the Document node
+ **/
+class RootExpr : public Expr {
+ public:
+ /**
+ * Creates a new RootExpr
+ */
+ RootExpr()
+#ifdef TX_TO_STRING
+ : mSerialize(true)
+#endif
+ {
+ }
+
+ TX_DECL_EXPR
+
+#ifdef TX_TO_STRING
+ public:
+ void setSerialize(bool aSerialize) { mSerialize = aSerialize; }
+
+ private:
+ // When a RootExpr is used in a PathExpr it shouldn't be serialized
+ bool mSerialize;
+#endif
+}; //-- RootExpr
+
+/**
+ * Represents a UnionExpr
+ **/
+class UnionExpr : public Expr {
+ public:
+ /**
+ * Adds the PathExpr to this UnionExpr
+ * The ownership of the given Expr is passed over the UnionExpr,
+ * even on failure.
+ * @param aExpr the Expr to add to this UnionExpr
+ */
+ void addExpr(Expr* aExpr) { mExpressions.AppendElement(aExpr); }
+
+ /**
+ * Removes and deletes the expression at the given index.
+ */
+ void deleteExprAt(uint32_t aPos) {
+ NS_ASSERTION(aPos < mExpressions.Length(), "killing bad expression index");
+
+ delete mExpressions[aPos];
+ mExpressions.RemoveElementAt(aPos);
+ }
+
+ TX_DECL_OPTIMIZABLE_EXPR
+
+ private:
+ txOwningArray<Expr> mExpressions;
+
+}; //-- UnionExpr
+
+/**
+ * Class specializing in executing expressions like "@foo" where we are
+ * interested in different result-types, and expressions like "@foo = 'hi'"
+ */
+class txNamedAttributeStep : public Expr {
+ public:
+ txNamedAttributeStep(int32_t aNsID, nsAtom* aPrefix, nsAtom* aLocalName);
+
+ TX_DECL_EXPR
+
+ private:
+ int32_t mNamespace;
+ RefPtr<nsAtom> mPrefix;
+ RefPtr<nsAtom> mLocalName;
+};
+
+/**
+ *
+ */
+class txUnionNodeTest : public txNodeTest {
+ public:
+ void addNodeTest(txNodeTest* aNodeTest) {
+ mNodeTests.AppendElement(aNodeTest);
+ }
+
+ TX_DECL_NODE_TEST
+
+ private:
+ txOwningArray<txNodeTest> mNodeTests;
+};
+
+/**
+ * Expression that failed to parse
+ */
+class txErrorExpr : public Expr {
+ public:
+#ifdef TX_TO_STRING
+ explicit txErrorExpr(const nsAString& aStr) : mStr(aStr) {}
+#endif
+
+ TX_DECL_EXPR
+
+#ifdef TX_TO_STRING
+ private:
+ nsString mStr;
+#endif
+};
+
+#endif
diff --git a/dom/xslt/xpath/txExprLexer.cpp b/dom/xslt/xpath/txExprLexer.cpp
new file mode 100644
index 0000000000..391dc2e875
--- /dev/null
+++ b/dom/xslt/xpath/txExprLexer.cpp
@@ -0,0 +1,333 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Lexical analyzer for XPath expressions
+ */
+
+#include "txExprLexer.h"
+#include "nsGkAtoms.h"
+#include "nsString.h"
+#include "nsError.h"
+#include "txXMLUtils.h"
+
+/**
+ * Creates a new ExprLexer
+ */
+txExprLexer::txExprLexer()
+ : mPosition(nullptr),
+ mCurrentItem(nullptr),
+ mFirstItem(nullptr),
+ mLastItem(nullptr),
+ mTokenCount(0) {}
+
+/**
+ * Destroys this instance of an txExprLexer
+ */
+txExprLexer::~txExprLexer() {
+ //-- delete tokens
+ Token* tok = mFirstItem;
+ while (tok) {
+ Token* temp = tok->mNext;
+ delete tok;
+ tok = temp;
+ }
+ mCurrentItem = nullptr;
+}
+
+Token* txExprLexer::nextToken() {
+ if (!mCurrentItem) {
+ MOZ_ASSERT_UNREACHABLE("nextToken called on uninitialized lexer");
+ return nullptr;
+ }
+
+ if (mCurrentItem->mType == Token::END) {
+ // Do not progress beyond the end token
+ return mCurrentItem;
+ }
+
+ Token* token = mCurrentItem;
+ mCurrentItem = mCurrentItem->mNext;
+ return token;
+}
+
+void txExprLexer::addToken(Token* aToken) {
+ if (mLastItem) {
+ mLastItem->mNext = aToken;
+ }
+ if (!mFirstItem) {
+ mFirstItem = aToken;
+ mCurrentItem = aToken;
+ }
+ mLastItem = aToken;
+ ++mTokenCount;
+}
+
+/**
+ * Returns true if the following Token should be an operator.
+ * This is a helper for the first bullet of [XPath 3.7]
+ * Lexical Structure
+ */
+bool txExprLexer::nextIsOperatorToken(Token* aToken) {
+ if (!aToken || aToken->mType == Token::NULL_TOKEN) {
+ return false;
+ }
+ /* This relies on the tokens having the right order in txExprLexer.h */
+ return aToken->mType < Token::COMMA || aToken->mType > Token::UNION_OP;
+}
+
+/**
+ * Parses the given string into a sequence of Tokens
+ */
+nsresult txExprLexer::parse(const nsAString& aPattern) {
+ iterator end;
+ aPattern.BeginReading(mPosition);
+ aPattern.EndReading(end);
+
+ //-- initialize previous token, this will automatically get
+ //-- deleted when it goes out of scope
+ Token nullToken(nullptr, nullptr, Token::NULL_TOKEN);
+
+ Token::Type defType;
+ Token* newToken = nullptr;
+ Token* prevToken = &nullToken;
+ bool isToken;
+
+ while (mPosition < end) {
+ defType = Token::CNAME;
+ isToken = true;
+
+ if (*mPosition == DOLLAR_SIGN) {
+ if (++mPosition == end || !XMLUtils::isLetter(*mPosition)) {
+ return NS_ERROR_XPATH_INVALID_VAR_NAME;
+ }
+ defType = Token::VAR_REFERENCE;
+ }
+ // just reuse the QName parsing, which will use defType
+ // the token to construct
+
+ if (XMLUtils::isLetter(*mPosition)) {
+ // NCName, can get QName or OperatorName;
+ // FunctionName, NodeName, and AxisSpecifier may want whitespace,
+ // and are dealt with below
+ iterator start = mPosition;
+ while (++mPosition < end && XMLUtils::isNCNameChar(*mPosition)) {
+ /* just go */
+ }
+ if (mPosition < end && *mPosition == COLON) {
+ // try QName or wildcard, might need to step back for axis
+ if (++mPosition == end) {
+ return NS_ERROR_XPATH_UNEXPECTED_END;
+ }
+ if (XMLUtils::isLetter(*mPosition)) {
+ while (++mPosition < end && XMLUtils::isNCNameChar(*mPosition)) {
+ /* just go */
+ }
+ } else if (*mPosition == '*' && defType != Token::VAR_REFERENCE) {
+ // eat wildcard for NameTest, bail for var ref at COLON
+ ++mPosition;
+ } else {
+ --mPosition; // step back
+ }
+ }
+ if (nextIsOperatorToken(prevToken)) {
+ nsDependentSubstring op(Substring(start, mPosition));
+ if (nsGkAtoms::_and->Equals(op)) {
+ defType = Token::AND_OP;
+ } else if (nsGkAtoms::_or->Equals(op)) {
+ defType = Token::OR_OP;
+ } else if (nsGkAtoms::mod->Equals(op)) {
+ defType = Token::MODULUS_OP;
+ } else if (nsGkAtoms::div->Equals(op)) {
+ defType = Token::DIVIDE_OP;
+ } else {
+ // XXX QUESTION: spec is not too precise
+ // badops is sure an error, but is bad:ops, too? We say yes!
+ return NS_ERROR_XPATH_OPERATOR_EXPECTED;
+ }
+ }
+ newToken = new Token(start, mPosition, defType);
+ } else if (isXPathDigit(*mPosition)) {
+ iterator start = mPosition;
+ while (++mPosition < end && isXPathDigit(*mPosition)) {
+ /* just go */
+ }
+ if (mPosition < end && *mPosition == '.') {
+ while (++mPosition < end && isXPathDigit(*mPosition)) {
+ /* just go */
+ }
+ }
+ newToken = new Token(start, mPosition, Token::NUMBER);
+ } else {
+ switch (*mPosition) {
+ //-- ignore whitespace
+ case SPACE:
+ case TX_TAB:
+ case TX_CR:
+ case TX_LF:
+ ++mPosition;
+ isToken = false;
+ break;
+ case S_QUOTE:
+ case D_QUOTE: {
+ iterator start = mPosition;
+ while (++mPosition < end && *mPosition != *start) {
+ // eat literal
+ }
+ if (mPosition == end) {
+ mPosition = start;
+ return NS_ERROR_XPATH_UNCLOSED_LITERAL;
+ }
+ newToken = new Token(start + 1, mPosition, Token::LITERAL);
+ ++mPosition;
+ } break;
+ case PERIOD:
+ // period can be .., .(DIGITS)+ or ., check next
+ if (++mPosition == end) {
+ newToken = new Token(mPosition - 1, Token::SELF_NODE);
+ } else if (isXPathDigit(*mPosition)) {
+ iterator start = mPosition - 1;
+ while (++mPosition < end && isXPathDigit(*mPosition)) {
+ /* just go */
+ }
+ newToken = new Token(start, mPosition, Token::NUMBER);
+ } else if (*mPosition == PERIOD) {
+ ++mPosition;
+ newToken = new Token(mPosition - 2, mPosition, Token::PARENT_NODE);
+ } else {
+ newToken = new Token(mPosition - 1, Token::SELF_NODE);
+ }
+ break;
+ case COLON: // QNames are dealt above, must be axis ident
+ if (++mPosition >= end || *mPosition != COLON ||
+ prevToken->mType != Token::CNAME) {
+ return NS_ERROR_XPATH_BAD_COLON;
+ }
+ prevToken->mType = Token::AXIS_IDENTIFIER;
+ ++mPosition;
+ isToken = false;
+ break;
+ case FORWARD_SLASH:
+ if (++mPosition < end && *mPosition == FORWARD_SLASH) {
+ ++mPosition;
+ newToken = new Token(mPosition - 2, mPosition, Token::ANCESTOR_OP);
+ } else {
+ newToken = new Token(mPosition - 1, Token::PARENT_OP);
+ }
+ break;
+ case BANG: // can only be !=
+ if (++mPosition < end && *mPosition == EQUAL) {
+ ++mPosition;
+ newToken = new Token(mPosition - 2, mPosition, Token::NOT_EQUAL_OP);
+ break;
+ }
+ // Error ! is not not()
+ return NS_ERROR_XPATH_BAD_BANG;
+ case EQUAL:
+ newToken = new Token(mPosition, Token::EQUAL_OP);
+ ++mPosition;
+ break;
+ case L_ANGLE:
+ if (++mPosition == end) {
+ return NS_ERROR_XPATH_UNEXPECTED_END;
+ }
+ if (*mPosition == EQUAL) {
+ ++mPosition;
+ newToken =
+ new Token(mPosition - 2, mPosition, Token::LESS_OR_EQUAL_OP);
+ } else {
+ newToken = new Token(mPosition - 1, Token::LESS_THAN_OP);
+ }
+ break;
+ case R_ANGLE:
+ if (++mPosition == end) {
+ return NS_ERROR_XPATH_UNEXPECTED_END;
+ }
+ if (*mPosition == EQUAL) {
+ ++mPosition;
+ newToken =
+ new Token(mPosition - 2, mPosition, Token::GREATER_OR_EQUAL_OP);
+ } else {
+ newToken = new Token(mPosition - 1, Token::GREATER_THAN_OP);
+ }
+ break;
+ case HYPHEN:
+ newToken = new Token(mPosition, Token::SUBTRACTION_OP);
+ ++mPosition;
+ break;
+ case ASTERISK:
+ if (nextIsOperatorToken(prevToken)) {
+ newToken = new Token(mPosition, Token::MULTIPLY_OP);
+ } else {
+ newToken = new Token(mPosition, Token::CNAME);
+ }
+ ++mPosition;
+ break;
+ case L_PAREN:
+ if (prevToken->mType == Token::CNAME) {
+ const nsDependentSubstring& val = prevToken->Value();
+ if (val.EqualsLiteral("comment")) {
+ prevToken->mType = Token::COMMENT_AND_PAREN;
+ } else if (val.EqualsLiteral("node")) {
+ prevToken->mType = Token::NODE_AND_PAREN;
+ } else if (val.EqualsLiteral("processing-instruction")) {
+ prevToken->mType = Token::PROC_INST_AND_PAREN;
+ } else if (val.EqualsLiteral("text")) {
+ prevToken->mType = Token::TEXT_AND_PAREN;
+ } else {
+ prevToken->mType = Token::FUNCTION_NAME_AND_PAREN;
+ }
+ isToken = false;
+ } else {
+ newToken = new Token(mPosition, Token::L_PAREN);
+ }
+ ++mPosition;
+ break;
+ case R_PAREN:
+ newToken = new Token(mPosition, Token::R_PAREN);
+ ++mPosition;
+ break;
+ case L_BRACKET:
+ newToken = new Token(mPosition, Token::L_BRACKET);
+ ++mPosition;
+ break;
+ case R_BRACKET:
+ newToken = new Token(mPosition, Token::R_BRACKET);
+ ++mPosition;
+ break;
+ case COMMA:
+ newToken = new Token(mPosition, Token::COMMA);
+ ++mPosition;
+ break;
+ case AT_SIGN:
+ newToken = new Token(mPosition, Token::AT_SIGN);
+ ++mPosition;
+ break;
+ case PLUS:
+ newToken = new Token(mPosition, Token::ADDITION_OP);
+ ++mPosition;
+ break;
+ case VERT_BAR:
+ newToken = new Token(mPosition, Token::UNION_OP);
+ ++mPosition;
+ break;
+ default:
+ // Error, don't grok character :-(
+ return NS_ERROR_XPATH_ILLEGAL_CHAR;
+ }
+ }
+ if (isToken) {
+ NS_ENSURE_TRUE(newToken != mLastItem, NS_ERROR_FAILURE);
+ prevToken = newToken;
+ addToken(newToken);
+ }
+ }
+
+ // add a endToken to the list
+ newToken = new Token(end, end, Token::END);
+ addToken(newToken);
+
+ return NS_OK;
+}
diff --git a/dom/xslt/xpath/txExprLexer.h b/dom/xslt/xpath/txExprLexer.h
new file mode 100644
index 0000000000..9d3ca2810e
--- /dev/null
+++ b/dom/xslt/xpath/txExprLexer.h
@@ -0,0 +1,200 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef MITREXSL_EXPRLEXER_H
+#define MITREXSL_EXPRLEXER_H
+
+#include "txCore.h"
+#include "nsString.h"
+
+/**
+ * A Token class for the ExprLexer.
+ *
+ * This class was ported from XSL:P, an open source Java based
+ * XSLT processor, written by yours truly.
+ */
+class Token {
+ public:
+ /**
+ * Token types
+ */
+ enum Type {
+ //-- Trivial Tokens
+ NULL_TOKEN = 1,
+ LITERAL,
+ NUMBER,
+ CNAME,
+ VAR_REFERENCE,
+ PARENT_NODE,
+ SELF_NODE,
+ R_PAREN,
+ R_BRACKET, // 9
+ /**
+ * start of tokens for 3.7, bullet 1
+ * ExprLexer::nextIsOperatorToken bails if the tokens aren't
+ * consecutive.
+ */
+ COMMA,
+ AT_SIGN,
+ L_PAREN,
+ L_BRACKET,
+ AXIS_IDENTIFIER,
+
+ // These tokens include their following left parenthesis
+ FUNCTION_NAME_AND_PAREN, // 15
+ COMMENT_AND_PAREN,
+ NODE_AND_PAREN,
+ PROC_INST_AND_PAREN,
+ TEXT_AND_PAREN,
+
+ /**
+ * operators
+ */
+ //-- boolean ops
+ AND_OP, // 20
+ OR_OP,
+
+ //-- relational
+ EQUAL_OP, // 22
+ NOT_EQUAL_OP,
+ LESS_THAN_OP,
+ GREATER_THAN_OP,
+ LESS_OR_EQUAL_OP,
+ GREATER_OR_EQUAL_OP,
+ //-- additive operators
+ ADDITION_OP, // 28
+ SUBTRACTION_OP,
+ //-- multiplicative
+ DIVIDE_OP, // 30
+ MULTIPLY_OP,
+ MODULUS_OP,
+ //-- path operators
+ PARENT_OP, // 33
+ ANCESTOR_OP,
+ UNION_OP,
+ /**
+ * end of tokens for 3.7, bullet 1 -/
+ */
+ //-- Special endtoken
+ END // 36
+ };
+
+ /**
+ * Constructors
+ */
+ using iterator = nsAString::const_char_iterator;
+
+ Token(iterator aStart, iterator aEnd, Type aType)
+ : mStart(aStart), mEnd(aEnd), mType(aType), mNext(nullptr) {}
+ Token(iterator aChar, Type aType)
+ : mStart(aChar), mEnd(aChar + 1), mType(aType), mNext(nullptr) {}
+
+ const nsDependentSubstring Value() { return Substring(mStart, mEnd); }
+
+ iterator mStart, mEnd;
+ Type mType;
+ Token* mNext;
+};
+
+/**
+ * A class for splitting an "Expr" String into tokens and
+ * performing basic Lexical Analysis.
+ *
+ * This class was ported from XSL:P, an open source Java based XSL processor
+ */
+
+class txExprLexer {
+ public:
+ txExprLexer();
+ ~txExprLexer();
+
+ /**
+ * Parse the given string.
+ * returns an error result if lexing failed.
+ * The given string must outlive the use of the lexer, as the
+ * generated Tokens point to Substrings of it.
+ * mPosition points to the offending location in case of an error.
+ */
+ nsresult parse(const nsAString& aPattern);
+
+ using iterator = nsAString::const_char_iterator;
+ iterator mPosition;
+
+ /**
+ * Functions for iterating over the TokenList
+ */
+
+ Token* nextToken();
+ Token* peek() {
+ NS_ASSERTION(mCurrentItem, "peek called uninitialized lexer");
+ return mCurrentItem;
+ }
+ Token* peekAhead() {
+ NS_ASSERTION(mCurrentItem, "peekAhead called on uninitialized lexer");
+ // Don't peek past the end node
+ return (mCurrentItem && mCurrentItem->mNext) ? mCurrentItem->mNext
+ : mCurrentItem;
+ }
+ bool hasMoreTokens() {
+ NS_ASSERTION(mCurrentItem, "HasMoreTokens called on uninitialized lexer");
+ return (mCurrentItem && mCurrentItem->mType != Token::END);
+ }
+
+ /**
+ * Trivial Tokens
+ */
+ //-- LF, changed to enum
+ enum _TrivialTokens {
+ D_QUOTE = '\"',
+ S_QUOTE = '\'',
+ L_PAREN = '(',
+ R_PAREN = ')',
+ L_BRACKET = '[',
+ R_BRACKET = ']',
+ L_ANGLE = '<',
+ R_ANGLE = '>',
+ COMMA = ',',
+ PERIOD = '.',
+ ASTERISK = '*',
+ FORWARD_SLASH = '/',
+ EQUAL = '=',
+ BANG = '!',
+ VERT_BAR = '|',
+ AT_SIGN = '@',
+ DOLLAR_SIGN = '$',
+ PLUS = '+',
+ HYPHEN = '-',
+ COLON = ':',
+ //-- whitespace tokens
+ SPACE = ' ',
+ TX_TAB = '\t',
+ TX_CR = '\n',
+ TX_LF = '\r'
+ };
+
+ private:
+ Token* mCurrentItem;
+ Token* mFirstItem;
+ Token* mLastItem;
+
+ int mTokenCount;
+
+ void addToken(Token* aToken);
+
+ /**
+ * Returns true if the following Token should be an operator.
+ * This is a helper for the first bullet of [XPath 3.7]
+ * Lexical Structure
+ */
+ bool nextIsOperatorToken(Token* aToken);
+
+ /**
+ * Returns true if the given character represents a numeric letter (digit)
+ * Implemented in ExprLexerChars.cpp
+ */
+ static bool isXPathDigit(char16_t ch) { return (ch >= '0' && ch <= '9'); }
+};
+
+#endif
diff --git a/dom/xslt/xpath/txExprParser.cpp b/dom/xslt/xpath/txExprParser.cpp
new file mode 100644
index 0000000000..47f142d023
--- /dev/null
+++ b/dom/xslt/xpath/txExprParser.cpp
@@ -0,0 +1,855 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * ExprParser
+ * This class is used to parse XSL Expressions
+ * @see ExprLexer
+ **/
+
+#include "txExprParser.h"
+
+#include <utility>
+
+#include "mozilla/UniquePtrExtensions.h"
+#include "nsError.h"
+#include "nsGkAtoms.h"
+#include "txExpr.h"
+#include "txExprLexer.h"
+#include "txIXPathContext.h"
+#include "txStack.h"
+#include "txStringUtils.h"
+#include "txXPathNode.h"
+#include "txXPathOptimizer.h"
+
+using mozilla::MakeUnique;
+using mozilla::UniquePtr;
+using mozilla::Unused;
+using mozilla::WrapUnique;
+
+/**
+ * Creates an Attribute Value Template using the given value
+ * This should move to XSLProcessor class
+ */
+nsresult txExprParser::createAVT(const nsAString& aAttrValue,
+ txIParseContext* aContext, Expr** aResult) {
+ *aResult = nullptr;
+ nsresult rv = NS_OK;
+ UniquePtr<Expr> expr;
+ FunctionCall* concat = nullptr;
+
+ nsAutoString literalString;
+ bool inExpr = false;
+ nsAString::const_char_iterator iter, start, end, avtStart;
+ aAttrValue.BeginReading(iter);
+ aAttrValue.EndReading(end);
+ avtStart = iter;
+
+ while (iter != end) {
+ // Every iteration through this loop parses either a literal section
+ // or an expression
+ start = iter;
+ UniquePtr<Expr> newExpr;
+ if (!inExpr) {
+ // Parse literal section
+ literalString.Truncate();
+ while (iter != end) {
+ char16_t q = *iter;
+ if (q == '{' || q == '}') {
+ // Store what we've found so far and set a new |start| to
+ // skip the (first) brace
+ literalString.Append(Substring(start, iter));
+ start = ++iter;
+ // Unless another brace follows we've found the start of
+ // an expression (in case of '{') or an unbalanced brace
+ // (in case of '}')
+ if (iter == end || *iter != q) {
+ if (q == '}') {
+ aContext->SetErrorOffset(iter - avtStart);
+ return NS_ERROR_XPATH_UNBALANCED_CURLY_BRACE;
+ }
+
+ inExpr = true;
+ break;
+ }
+ // We found a second brace, let that be part of the next
+ // literal section being parsed and continue looping
+ }
+ ++iter;
+ }
+
+ if (start == iter && literalString.IsEmpty()) {
+ // Restart the loop since we didn't create an expression
+ continue;
+ }
+ newExpr =
+ MakeUnique<txLiteralExpr>(literalString + Substring(start, iter));
+ } else {
+ // Parse expressions, iter is already past the initial '{' when
+ // we get here.
+ while (iter != end) {
+ if (*iter == '}') {
+ rv = createExprInternal(Substring(start, iter), start - avtStart,
+ aContext, getter_Transfers(newExpr));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ inExpr = false;
+ ++iter; // skip closing '}'
+ break;
+ } else if (*iter == '\'' || *iter == '"') {
+ char16_t q = *iter;
+ while (++iter != end && *iter != q) {
+ } /* do nothing */
+ if (iter == end) {
+ break;
+ }
+ }
+ ++iter;
+ }
+
+ if (inExpr) {
+ aContext->SetErrorOffset(start - avtStart);
+ return NS_ERROR_XPATH_UNBALANCED_CURLY_BRACE;
+ }
+ }
+
+ // Add expression, create a concat() call if necessary
+ if (!expr) {
+ expr = std::move(newExpr);
+ } else {
+ if (!concat) {
+ concat = new txCoreFunctionCall(txCoreFunctionCall::CONCAT);
+ concat->addParam(expr.release());
+ expr = WrapUnique(concat);
+ }
+
+ concat->addParam(newExpr.release());
+ }
+ }
+
+ if (inExpr) {
+ aContext->SetErrorOffset(iter - avtStart);
+ return NS_ERROR_XPATH_UNBALANCED_CURLY_BRACE;
+ }
+
+ if (!expr) {
+ expr = MakeUnique<txLiteralExpr>(u""_ns);
+ }
+
+ *aResult = expr.release();
+
+ return NS_OK;
+}
+
+nsresult txExprParser::createExprInternal(const nsAString& aExpression,
+ uint32_t aSubStringPos,
+ txIParseContext* aContext,
+ Expr** aExpr) {
+ NS_ENSURE_ARG_POINTER(aExpr);
+ *aExpr = nullptr;
+ txExprLexer lexer;
+ nsresult rv = lexer.parse(aExpression);
+ if (NS_FAILED(rv)) {
+ nsAString::const_char_iterator start;
+ aExpression.BeginReading(start);
+ aContext->SetErrorOffset(lexer.mPosition - start + aSubStringPos);
+ return rv;
+ }
+ UniquePtr<Expr> expr;
+ rv = createExpr(lexer, aContext, getter_Transfers(expr));
+ if (NS_SUCCEEDED(rv) && lexer.peek()->mType != Token::END) {
+ rv = NS_ERROR_XPATH_BINARY_EXPECTED;
+ }
+ if (NS_FAILED(rv)) {
+ nsAString::const_char_iterator start;
+ aExpression.BeginReading(start);
+ aContext->SetErrorOffset(lexer.peek()->mStart - start + aSubStringPos);
+
+ return rv;
+ }
+
+ txXPathOptimizer optimizer;
+ Expr* newExpr = nullptr;
+ optimizer.optimize(expr.get(), &newExpr);
+
+ *aExpr = newExpr ? newExpr : expr.release();
+
+ return NS_OK;
+}
+
+/**
+ * Private Methods
+ */
+
+/**
+ * Creates a binary Expr for the given operator
+ */
+nsresult txExprParser::createBinaryExpr(UniquePtr<Expr>& left,
+ UniquePtr<Expr>& right, Token* op,
+ Expr** aResult) {
+ NS_ASSERTION(op, "internal error");
+ *aResult = nullptr;
+
+ Expr* expr = nullptr;
+ switch (op->mType) {
+ //-- math ops
+ case Token::ADDITION_OP:
+ expr = new txNumberExpr(left.get(), right.get(), txNumberExpr::ADD);
+ break;
+ case Token::SUBTRACTION_OP:
+ expr = new txNumberExpr(left.get(), right.get(), txNumberExpr::SUBTRACT);
+ break;
+ case Token::DIVIDE_OP:
+ expr = new txNumberExpr(left.get(), right.get(), txNumberExpr::DIVIDE);
+ break;
+ case Token::MODULUS_OP:
+ expr = new txNumberExpr(left.get(), right.get(), txNumberExpr::MODULUS);
+ break;
+ case Token::MULTIPLY_OP:
+ expr = new txNumberExpr(left.get(), right.get(), txNumberExpr::MULTIPLY);
+ break;
+
+ //-- case boolean ops
+ case Token::AND_OP:
+ expr = new BooleanExpr(left.get(), right.get(), BooleanExpr::AND);
+ break;
+ case Token::OR_OP:
+ expr = new BooleanExpr(left.get(), right.get(), BooleanExpr::OR);
+ break;
+
+ //-- equality ops
+ case Token::EQUAL_OP:
+ expr = new RelationalExpr(left.get(), right.get(), RelationalExpr::EQUAL);
+ break;
+ case Token::NOT_EQUAL_OP:
+ expr = new RelationalExpr(left.get(), right.get(),
+ RelationalExpr::NOT_EQUAL);
+ break;
+
+ //-- relational ops
+ case Token::LESS_THAN_OP:
+ expr = new RelationalExpr(left.get(), right.get(),
+ RelationalExpr::LESS_THAN);
+ break;
+ case Token::GREATER_THAN_OP:
+ expr = new RelationalExpr(left.get(), right.get(),
+ RelationalExpr::GREATER_THAN);
+ break;
+ case Token::LESS_OR_EQUAL_OP:
+ expr = new RelationalExpr(left.get(), right.get(),
+ RelationalExpr::LESS_OR_EQUAL);
+ break;
+ case Token::GREATER_OR_EQUAL_OP:
+ expr = new RelationalExpr(left.get(), right.get(),
+ RelationalExpr::GREATER_OR_EQUAL);
+ break;
+
+ default:
+ MOZ_ASSERT_UNREACHABLE("operator tokens should be already checked");
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ Unused << left.release();
+ Unused << right.release();
+
+ *aResult = expr;
+ return NS_OK;
+}
+
+nsresult txExprParser::createExpr(txExprLexer& lexer, txIParseContext* aContext,
+ Expr** aResult) {
+ *aResult = nullptr;
+
+ nsresult rv = NS_OK;
+ bool done = false;
+
+ UniquePtr<Expr> expr;
+
+ txStack exprs;
+ txStack ops;
+
+ while (!done) {
+ uint16_t negations = 0;
+ while (lexer.peek()->mType == Token::SUBTRACTION_OP) {
+ negations++;
+ lexer.nextToken();
+ }
+
+ rv = createUnionExpr(lexer, aContext, getter_Transfers(expr));
+ if (NS_FAILED(rv)) {
+ break;
+ }
+
+ if (negations > 0) {
+ if (negations % 2 == 0) {
+ auto fcExpr =
+ MakeUnique<txCoreFunctionCall>(txCoreFunctionCall::NUMBER);
+
+ fcExpr->addParam(expr.release());
+ expr = std::move(fcExpr);
+ } else {
+ expr = MakeUnique<UnaryExpr>(expr.release());
+ }
+ }
+
+ short tokPrecedence = precedence(lexer.peek());
+ if (tokPrecedence != 0) {
+ Token* tok = lexer.nextToken();
+ while (!exprs.isEmpty() &&
+ tokPrecedence <= precedence(static_cast<Token*>(ops.peek()))) {
+ // can't use expr as argument due to order of evaluation
+ UniquePtr<Expr> left(static_cast<Expr*>(exprs.pop()));
+ UniquePtr<Expr> right(std::move(expr));
+ rv = createBinaryExpr(left, right, static_cast<Token*>(ops.pop()),
+ getter_Transfers(expr));
+ if (NS_FAILED(rv)) {
+ done = true;
+ break;
+ }
+ }
+ exprs.push(expr.release());
+ ops.push(tok);
+ } else {
+ done = true;
+ }
+ }
+
+ while (NS_SUCCEEDED(rv) && !exprs.isEmpty()) {
+ UniquePtr<Expr> left(static_cast<Expr*>(exprs.pop()));
+ UniquePtr<Expr> right(std::move(expr));
+ rv = createBinaryExpr(left, right, static_cast<Token*>(ops.pop()),
+ getter_Transfers(expr));
+ }
+ // clean up on error
+ while (!exprs.isEmpty()) {
+ delete static_cast<Expr*>(exprs.pop());
+ }
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ *aResult = expr.release();
+ return NS_OK;
+}
+
+nsresult txExprParser::createFilterOrStep(txExprLexer& lexer,
+ txIParseContext* aContext,
+ Expr** aResult) {
+ *aResult = nullptr;
+
+ nsresult rv = NS_OK;
+ Token* tok = lexer.peek();
+
+ UniquePtr<Expr> expr;
+ switch (tok->mType) {
+ case Token::FUNCTION_NAME_AND_PAREN:
+ rv = createFunctionCall(lexer, aContext, getter_Transfers(expr));
+ NS_ENSURE_SUCCESS(rv, rv);
+ break;
+ case Token::VAR_REFERENCE:
+ lexer.nextToken();
+ {
+ RefPtr<nsAtom> prefix, lName;
+ int32_t nspace;
+ nsresult rv = resolveQName(tok->Value(), getter_AddRefs(prefix),
+ aContext, getter_AddRefs(lName), nspace);
+ NS_ENSURE_SUCCESS(rv, rv);
+ expr = MakeUnique<VariableRefExpr>(prefix, lName, nspace);
+ }
+ break;
+ case Token::L_PAREN:
+ lexer.nextToken();
+ rv = createExpr(lexer, aContext, getter_Transfers(expr));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (lexer.peek()->mType != Token::R_PAREN) {
+ return NS_ERROR_XPATH_PAREN_EXPECTED;
+ }
+ lexer.nextToken();
+ break;
+ case Token::LITERAL:
+ lexer.nextToken();
+ expr = MakeUnique<txLiteralExpr>(tok->Value());
+ break;
+ case Token::NUMBER: {
+ lexer.nextToken();
+ expr = MakeUnique<txLiteralExpr>(txDouble::toDouble(tok->Value()));
+ break;
+ }
+ default:
+ return createLocationStep(lexer, aContext, aResult);
+ }
+
+ if (lexer.peek()->mType == Token::L_BRACKET) {
+ UniquePtr<FilterExpr> filterExpr(new FilterExpr(expr.get()));
+
+ Unused << expr.release();
+
+ //-- handle predicates
+ rv = parsePredicates(filterExpr.get(), lexer, aContext);
+ NS_ENSURE_SUCCESS(rv, rv);
+ expr = std::move(filterExpr);
+ }
+
+ *aResult = expr.release();
+ return NS_OK;
+}
+
+nsresult txExprParser::createFunctionCall(txExprLexer& lexer,
+ txIParseContext* aContext,
+ Expr** aResult) {
+ *aResult = nullptr;
+
+ UniquePtr<FunctionCall> fnCall;
+
+ Token* tok = lexer.nextToken();
+ NS_ASSERTION(tok->mType == Token::FUNCTION_NAME_AND_PAREN,
+ "FunctionCall expected");
+
+ //-- compare function names
+ RefPtr<nsAtom> prefix, lName;
+ int32_t namespaceID;
+ nsresult rv = resolveQName(tok->Value(), getter_AddRefs(prefix), aContext,
+ getter_AddRefs(lName), namespaceID);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ txCoreFunctionCall::eType type;
+ if (namespaceID == kNameSpaceID_None &&
+ txCoreFunctionCall::getTypeFromAtom(lName, type)) {
+ // It is a known built-in function.
+ fnCall = MakeUnique<txCoreFunctionCall>(type);
+ }
+
+ // check extension functions and xslt
+ if (!fnCall) {
+ rv = aContext->resolveFunctionCall(lName, namespaceID,
+ getter_Transfers(fnCall));
+
+ if (rv == NS_ERROR_NOT_IMPLEMENTED) {
+ // this should just happen for unparsed-entity-uri()
+ NS_ASSERTION(!fnCall, "Now is it implemented or not?");
+ rv = parseParameters(0, lexer, aContext);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ *aResult = new txLiteralExpr(tok->Value() + u" not implemented."_ns);
+
+ return NS_OK;
+ }
+
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ //-- handle parametes
+ rv = parseParameters(fnCall.get(), lexer, aContext);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ *aResult = fnCall.release();
+ return NS_OK;
+}
+
+nsresult txExprParser::createLocationStep(txExprLexer& lexer,
+ txIParseContext* aContext,
+ Expr** aExpr) {
+ *aExpr = nullptr;
+
+ //-- child axis is default
+ LocationStep::LocationStepType axisIdentifier = LocationStep::CHILD_AXIS;
+ UniquePtr<txNodeTest> nodeTest;
+
+ //-- get Axis Identifier or AbbreviatedStep, if present
+ Token* tok = lexer.peek();
+ switch (tok->mType) {
+ case Token::AXIS_IDENTIFIER: {
+ //-- eat token
+ lexer.nextToken();
+ RefPtr<nsAtom> axis = NS_Atomize(tok->Value());
+ if (axis == nsGkAtoms::ancestor) {
+ axisIdentifier = LocationStep::ANCESTOR_AXIS;
+ } else if (axis == nsGkAtoms::ancestorOrSelf) {
+ axisIdentifier = LocationStep::ANCESTOR_OR_SELF_AXIS;
+ } else if (axis == nsGkAtoms::attribute) {
+ axisIdentifier = LocationStep::ATTRIBUTE_AXIS;
+ } else if (axis == nsGkAtoms::child) {
+ axisIdentifier = LocationStep::CHILD_AXIS;
+ } else if (axis == nsGkAtoms::descendant) {
+ axisIdentifier = LocationStep::DESCENDANT_AXIS;
+ } else if (axis == nsGkAtoms::descendantOrSelf) {
+ axisIdentifier = LocationStep::DESCENDANT_OR_SELF_AXIS;
+ } else if (axis == nsGkAtoms::following) {
+ axisIdentifier = LocationStep::FOLLOWING_AXIS;
+ } else if (axis == nsGkAtoms::followingSibling) {
+ axisIdentifier = LocationStep::FOLLOWING_SIBLING_AXIS;
+ } else if (axis == nsGkAtoms::_namespace) {
+ axisIdentifier = LocationStep::NAMESPACE_AXIS;
+ } else if (axis == nsGkAtoms::parent) {
+ axisIdentifier = LocationStep::PARENT_AXIS;
+ } else if (axis == nsGkAtoms::preceding) {
+ axisIdentifier = LocationStep::PRECEDING_AXIS;
+ } else if (axis == nsGkAtoms::precedingSibling) {
+ axisIdentifier = LocationStep::PRECEDING_SIBLING_AXIS;
+ } else if (axis == nsGkAtoms::self) {
+ axisIdentifier = LocationStep::SELF_AXIS;
+ } else {
+ return NS_ERROR_XPATH_INVALID_AXIS;
+ }
+ break;
+ }
+ case Token::AT_SIGN:
+ //-- eat token
+ lexer.nextToken();
+ axisIdentifier = LocationStep::ATTRIBUTE_AXIS;
+ break;
+ case Token::PARENT_NODE:
+ //-- eat token
+ lexer.nextToken();
+ axisIdentifier = LocationStep::PARENT_AXIS;
+ nodeTest = MakeUnique<txNodeTypeTest>(txNodeTypeTest::NODE_TYPE);
+ break;
+ case Token::SELF_NODE:
+ //-- eat token
+ lexer.nextToken();
+ axisIdentifier = LocationStep::SELF_AXIS;
+ nodeTest = MakeUnique<txNodeTypeTest>(txNodeTypeTest::NODE_TYPE);
+ break;
+ default:
+ break;
+ }
+
+ //-- get NodeTest unless an AbbreviatedStep was found
+ nsresult rv = NS_OK;
+ if (!nodeTest) {
+ tok = lexer.peek();
+
+ if (tok->mType == Token::CNAME) {
+ lexer.nextToken();
+ // resolve QName
+ RefPtr<nsAtom> prefix, lName;
+ int32_t nspace;
+ rv = resolveQName(tok->Value(), getter_AddRefs(prefix), aContext,
+ getter_AddRefs(lName), nspace, true);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ nodeTest = MakeUnique<txNameTest>(
+ prefix, lName, nspace,
+ axisIdentifier == LocationStep::ATTRIBUTE_AXIS
+ ? static_cast<uint16_t>(txXPathNodeType::ATTRIBUTE_NODE)
+ : static_cast<uint16_t>(txXPathNodeType::ELEMENT_NODE));
+ } else {
+ rv = createNodeTypeTest(lexer, getter_Transfers(nodeTest));
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ }
+
+ UniquePtr<LocationStep> lstep(
+ new LocationStep(nodeTest.get(), axisIdentifier));
+
+ Unused << nodeTest.release();
+
+ //-- handle predicates
+ rv = parsePredicates(lstep.get(), lexer, aContext);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ *aExpr = lstep.release();
+ return NS_OK;
+}
+
+/**
+ * This method only handles comment(), text(), processing-instructing()
+ * and node()
+ */
+nsresult txExprParser::createNodeTypeTest(txExprLexer& lexer,
+ txNodeTest** aTest) {
+ *aTest = 0;
+ UniquePtr<txNodeTypeTest> nodeTest;
+
+ Token* nodeTok = lexer.peek();
+
+ switch (nodeTok->mType) {
+ case Token::COMMENT_AND_PAREN:
+ lexer.nextToken();
+ nodeTest = MakeUnique<txNodeTypeTest>(txNodeTypeTest::COMMENT_TYPE);
+ break;
+ case Token::NODE_AND_PAREN:
+ lexer.nextToken();
+ nodeTest = MakeUnique<txNodeTypeTest>(txNodeTypeTest::NODE_TYPE);
+ break;
+ case Token::PROC_INST_AND_PAREN:
+ lexer.nextToken();
+ nodeTest = MakeUnique<txNodeTypeTest>(txNodeTypeTest::PI_TYPE);
+ break;
+ case Token::TEXT_AND_PAREN:
+ lexer.nextToken();
+ nodeTest = MakeUnique<txNodeTypeTest>(txNodeTypeTest::TEXT_TYPE);
+ break;
+ default:
+ return NS_ERROR_XPATH_NO_NODE_TYPE_TEST;
+ }
+
+ if (nodeTok->mType == Token::PROC_INST_AND_PAREN &&
+ lexer.peek()->mType == Token::LITERAL) {
+ Token* tok = lexer.nextToken();
+ nodeTest->setNodeName(tok->Value());
+ }
+ if (lexer.peek()->mType != Token::R_PAREN) {
+ return NS_ERROR_XPATH_PAREN_EXPECTED;
+ }
+ lexer.nextToken();
+
+ *aTest = nodeTest.release();
+ return NS_OK;
+}
+
+/**
+ * Creates a PathExpr using the given txExprLexer
+ * @param lexer the txExprLexer for retrieving Tokens
+ */
+nsresult txExprParser::createPathExpr(txExprLexer& lexer,
+ txIParseContext* aContext,
+ Expr** aResult) {
+ *aResult = nullptr;
+
+ UniquePtr<Expr> expr;
+
+ Token* tok = lexer.peek();
+
+ // is this a root expression?
+ if (tok->mType == Token::PARENT_OP) {
+ if (!isLocationStepToken(lexer.peekAhead())) {
+ lexer.nextToken();
+ *aResult = new RootExpr();
+ return NS_OK;
+ }
+ }
+
+ // parse first step (possibly a FilterExpr)
+ nsresult rv = NS_OK;
+ if (tok->mType != Token::PARENT_OP && tok->mType != Token::ANCESTOR_OP) {
+ rv = createFilterOrStep(lexer, aContext, getter_Transfers(expr));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // is this a singlestep path expression?
+ tok = lexer.peek();
+ if (tok->mType != Token::PARENT_OP && tok->mType != Token::ANCESTOR_OP) {
+ *aResult = expr.release();
+ return NS_OK;
+ }
+ } else {
+ expr = MakeUnique<RootExpr>();
+
+#ifdef TX_TO_STRING
+ static_cast<RootExpr*>(expr.get())->setSerialize(false);
+#endif
+ }
+
+ // We have a PathExpr containing several steps
+ UniquePtr<PathExpr> pathExpr(new PathExpr());
+ pathExpr->addExpr(expr.release(), PathExpr::RELATIVE_OP);
+
+ // this is ugly
+ while (1) {
+ PathExpr::PathOperator pathOp;
+ switch (lexer.peek()->mType) {
+ case Token::ANCESTOR_OP:
+ pathOp = PathExpr::DESCENDANT_OP;
+ break;
+ case Token::PARENT_OP:
+ pathOp = PathExpr::RELATIVE_OP;
+ break;
+ default:
+ *aResult = pathExpr.release();
+ return NS_OK;
+ }
+ lexer.nextToken();
+
+ rv = createLocationStep(lexer, aContext, getter_Transfers(expr));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ pathExpr->addExpr(expr.release(), pathOp);
+ }
+ MOZ_ASSERT_UNREACHABLE("internal xpath parser error");
+ return NS_ERROR_UNEXPECTED;
+}
+
+/**
+ * Creates a PathExpr using the given txExprLexer
+ * @param lexer the txExprLexer for retrieving Tokens
+ */
+nsresult txExprParser::createUnionExpr(txExprLexer& lexer,
+ txIParseContext* aContext,
+ Expr** aResult) {
+ *aResult = nullptr;
+
+ UniquePtr<Expr> expr;
+ nsresult rv = createPathExpr(lexer, aContext, getter_Transfers(expr));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (lexer.peek()->mType != Token::UNION_OP) {
+ *aResult = expr.release();
+ return NS_OK;
+ }
+
+ UniquePtr<UnionExpr> unionExpr(new UnionExpr());
+ unionExpr->addExpr(expr.release());
+
+ while (lexer.peek()->mType == Token::UNION_OP) {
+ lexer.nextToken(); //-- eat token
+
+ rv = createPathExpr(lexer, aContext, getter_Transfers(expr));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ unionExpr->addExpr(expr.release());
+ }
+
+ *aResult = unionExpr.release();
+ return NS_OK;
+}
+
+bool txExprParser::isLocationStepToken(Token* aToken) {
+ // We could put these in consecutive order in ExprLexer.h for speed
+ return aToken->mType == Token::AXIS_IDENTIFIER ||
+ aToken->mType == Token::AT_SIGN ||
+ aToken->mType == Token::PARENT_NODE ||
+ aToken->mType == Token::SELF_NODE || aToken->mType == Token::CNAME ||
+ aToken->mType == Token::COMMENT_AND_PAREN ||
+ aToken->mType == Token::NODE_AND_PAREN ||
+ aToken->mType == Token::PROC_INST_AND_PAREN ||
+ aToken->mType == Token::TEXT_AND_PAREN;
+}
+
+/**
+ * Using the given lexer, parses the tokens if they represent a predicate list
+ * If an error occurs a non-zero String pointer will be returned containing the
+ * error message.
+ * @param predicateList, the PredicateList to add predicate expressions to
+ * @param lexer the txExprLexer to use for parsing tokens
+ * @return 0 if successful, or a String pointer to the error message
+ */
+nsresult txExprParser::parsePredicates(PredicateList* aPredicateList,
+ txExprLexer& lexer,
+ txIParseContext* aContext) {
+ UniquePtr<Expr> expr;
+ nsresult rv = NS_OK;
+ while (lexer.peek()->mType == Token::L_BRACKET) {
+ //-- eat Token
+ lexer.nextToken();
+
+ rv = createExpr(lexer, aContext, getter_Transfers(expr));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aPredicateList->add(expr.release());
+
+ if (lexer.peek()->mType != Token::R_BRACKET) {
+ return NS_ERROR_XPATH_BRACKET_EXPECTED;
+ }
+ lexer.nextToken();
+ }
+ return NS_OK;
+}
+
+/**
+ * Using the given lexer, parses the tokens if they represent a parameter list
+ * If an error occurs a non-zero String pointer will be returned containing the
+ * error message.
+ * @param list, the List to add parameter expressions to
+ * @param lexer the txExprLexer to use for parsing tokens
+ * @return NS_OK if successful, or another rv otherwise
+ */
+nsresult txExprParser::parseParameters(FunctionCall* aFnCall,
+ txExprLexer& lexer,
+ txIParseContext* aContext) {
+ if (lexer.peek()->mType == Token::R_PAREN) {
+ lexer.nextToken();
+ return NS_OK;
+ }
+
+ UniquePtr<Expr> expr;
+ nsresult rv = NS_OK;
+ while (1) {
+ rv = createExpr(lexer, aContext, getter_Transfers(expr));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (aFnCall) {
+ aFnCall->addParam(expr.release());
+ }
+
+ switch (lexer.peek()->mType) {
+ case Token::R_PAREN:
+ lexer.nextToken();
+ return NS_OK;
+ case Token::COMMA: //-- param separator
+ lexer.nextToken();
+ break;
+ default:
+ return NS_ERROR_XPATH_PAREN_EXPECTED;
+ }
+ }
+
+ MOZ_ASSERT_UNREACHABLE("internal xpath parser error");
+ return NS_ERROR_UNEXPECTED;
+}
+
+short txExprParser::precedence(Token* aToken) {
+ switch (aToken->mType) {
+ case Token::OR_OP:
+ return 1;
+ case Token::AND_OP:
+ return 2;
+ //-- equality
+ case Token::EQUAL_OP:
+ case Token::NOT_EQUAL_OP:
+ return 3;
+ //-- relational
+ case Token::LESS_THAN_OP:
+ case Token::GREATER_THAN_OP:
+ case Token::LESS_OR_EQUAL_OP:
+ case Token::GREATER_OR_EQUAL_OP:
+ return 4;
+ //-- additive operators
+ case Token::ADDITION_OP:
+ case Token::SUBTRACTION_OP:
+ return 5;
+ //-- multiplicative
+ case Token::DIVIDE_OP:
+ case Token::MULTIPLY_OP:
+ case Token::MODULUS_OP:
+ return 6;
+ default:
+ break;
+ }
+ return 0;
+}
+
+nsresult txExprParser::resolveQName(const nsAString& aQName, nsAtom** aPrefix,
+ txIParseContext* aContext,
+ nsAtom** aLocalName, int32_t& aNamespace,
+ bool aIsNameTest) {
+ aNamespace = kNameSpaceID_None;
+ int32_t idx = aQName.FindChar(':');
+ if (idx > 0) {
+ *aPrefix = NS_Atomize(StringHead(aQName, (uint32_t)idx)).take();
+ if (!*aPrefix) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+ *aLocalName = NS_Atomize(Substring(aQName, (uint32_t)idx + 1,
+ aQName.Length() - (idx + 1)))
+ .take();
+ if (!*aLocalName) {
+ NS_RELEASE(*aPrefix);
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+ return aContext->resolveNamespacePrefix(*aPrefix, aNamespace);
+ }
+ // the lexer dealt with idx == 0
+ *aPrefix = 0;
+ if (aIsNameTest && aContext->caseInsensitiveNameTests()) {
+ nsAutoString lcname;
+ nsContentUtils::ASCIIToLower(aQName, lcname);
+ *aLocalName = NS_Atomize(lcname).take();
+ } else {
+ *aLocalName = NS_Atomize(aQName).take();
+ }
+ if (!*aLocalName) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+ return NS_OK;
+}
diff --git a/dom/xslt/xpath/txExprParser.h b/dom/xslt/xpath/txExprParser.h
new file mode 100644
index 0000000000..06c07cf232
--- /dev/null
+++ b/dom/xslt/xpath/txExprParser.h
@@ -0,0 +1,95 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * ExprParser
+ * This class is used to parse XSL Expressions
+ * @see ExprLexer
+ **/
+
+#ifndef MITREXSL_EXPRPARSER_H
+#define MITREXSL_EXPRPARSER_H
+
+#include "txCore.h"
+#include "mozilla/UniquePtr.h"
+#include "nsString.h"
+
+class Expr;
+class txExprLexer;
+class FunctionCall;
+class LocationStep;
+class nsAtom;
+class PredicateList;
+class Token;
+class txIParseContext;
+class txNodeTest;
+
+class txExprParser {
+ public:
+ static nsresult createExpr(const nsAString& aExpression,
+ txIParseContext* aContext, Expr** aExpr) {
+ return createExprInternal(aExpression, 0, aContext, aExpr);
+ }
+
+ /**
+ * Creates an Attribute Value Template using the given value
+ */
+ static nsresult createAVT(const nsAString& aAttrValue,
+ txIParseContext* aContext, Expr** aResult);
+
+ protected:
+ static nsresult createExprInternal(const nsAString& aExpression,
+ uint32_t aSubStringPos,
+ txIParseContext* aContext, Expr** aExpr);
+ /**
+ * Using nsAutoPtr& to optimize passing the ownership to the
+ * created binary expression objects.
+ */
+ static nsresult createBinaryExpr(mozilla::UniquePtr<Expr>& left,
+ mozilla::UniquePtr<Expr>& right, Token* op,
+ Expr** aResult);
+ static nsresult createExpr(txExprLexer& lexer, txIParseContext* aContext,
+ Expr** aResult);
+ static nsresult createFilterOrStep(txExprLexer& lexer,
+ txIParseContext* aContext, Expr** aResult);
+ static nsresult createFunctionCall(txExprLexer& lexer,
+ txIParseContext* aContext, Expr** aResult);
+ static nsresult createLocationStep(txExprLexer& lexer,
+ txIParseContext* aContext, Expr** aResult);
+ static nsresult createNodeTypeTest(txExprLexer& lexer, txNodeTest** aResult);
+ static nsresult createPathExpr(txExprLexer& lexer, txIParseContext* aContext,
+ Expr** aResult);
+ static nsresult createUnionExpr(txExprLexer& lexer, txIParseContext* aContext,
+ Expr** aResult);
+
+ static bool isLocationStepToken(Token* aToken);
+
+ static short precedence(Token* aToken);
+
+ /**
+ * Resolve a QName, given the mContext parse context.
+ * Returns prefix and localName as well as namespace ID
+ */
+ static nsresult resolveQName(const nsAString& aQName, nsAtom** aPrefix,
+ txIParseContext* aContext, nsAtom** aLocalName,
+ int32_t& aNamespace, bool aIsNameTest = false);
+
+ /**
+ * Using the given lexer, parses the tokens if they represent a
+ * predicate list
+ * If an error occurs a non-zero String pointer will be returned
+ * containing the error message.
+ * @param predicateList, the PredicateList to add predicate expressions to
+ * @param lexer the ExprLexer to use for parsing tokens
+ * @return 0 if successful, or a String pointer to the error message
+ */
+ static nsresult parsePredicates(PredicateList* aPredicateList,
+ txExprLexer& lexer,
+ txIParseContext* aContext);
+ static nsresult parseParameters(FunctionCall* aFnCall, txExprLexer& lexer,
+ txIParseContext* aContext);
+};
+
+#endif
diff --git a/dom/xslt/xpath/txExprResult.h b/dom/xslt/xpath/txExprResult.h
new file mode 100644
index 0000000000..5572b222f5
--- /dev/null
+++ b/dom/xslt/xpath/txExprResult.h
@@ -0,0 +1,118 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef TRANSFRMX_EXPRRESULT_H
+#define TRANSFRMX_EXPRRESULT_H
+
+#include "nsString.h"
+#include "txCore.h"
+#include "txResultRecycler.h"
+
+/*
+ * ExprResult
+ *
+ * Classes Represented:
+ * BooleanResult, ExprResult, NumberResult, StringResult
+ *
+ * Note: for NodeSet, see NodeSet.h
+ */
+
+class txAExprResult {
+ public:
+ friend class txResultRecycler;
+
+ // Update txLiteralExpr::getReturnType and sTypes in txEXSLTFunctions.cpp if
+ // this enum is changed.
+ enum ResultType {
+ NODESET = 0,
+ BOOLEAN,
+ NUMBER,
+ STRING,
+ RESULT_TREE_FRAGMENT
+ };
+
+ explicit txAExprResult(txResultRecycler* aRecycler) : mRecycler(aRecycler) {}
+ virtual ~txAExprResult() = default;
+
+ void AddRef() {
+ ++mRefCnt;
+ NS_LOG_ADDREF(this, mRefCnt, "txAExprResult", sizeof(*this));
+ }
+
+ void Release(); // Implemented in txResultRecycler.cpp
+
+ /**
+ * Returns the type of ExprResult represented
+ * @return the type of ExprResult represented
+ **/
+ virtual short getResultType() = 0;
+
+ /**
+ * Creates a String representation of this ExprResult
+ * @param aResult the destination string to append the String
+ * representation to.
+ **/
+ virtual void stringValue(nsString& aResult) = 0;
+
+ /**
+ * Returns a pointer to the stringvalue if possible. Otherwise null is
+ * returned.
+ */
+ virtual const nsString* stringValuePointer() = 0;
+
+ /**
+ * Converts this ExprResult to a Boolean (bool) value
+ * @return the Boolean value
+ **/
+ virtual bool booleanValue() = 0;
+
+ /**
+ * Converts this ExprResult to a Number (double) value
+ * @return the Number value
+ **/
+ virtual double numberValue() = 0;
+
+ private:
+ nsAutoRefCnt mRefCnt;
+ RefPtr<txResultRecycler> mRecycler;
+};
+
+#define TX_DECL_EXPRRESULT \
+ virtual short getResultType() override; \
+ virtual void stringValue(nsString& aString) override; \
+ virtual const nsString* stringValuePointer() override; \
+ virtual bool booleanValue() override; \
+ virtual double numberValue() override;
+
+class BooleanResult : public txAExprResult {
+ public:
+ explicit BooleanResult(bool aValue);
+
+ TX_DECL_EXPRRESULT
+
+ private:
+ bool value;
+};
+
+class NumberResult : public txAExprResult {
+ public:
+ NumberResult(double aValue, txResultRecycler* aRecycler);
+
+ TX_DECL_EXPRRESULT
+
+ double value;
+};
+
+class StringResult : public txAExprResult {
+ public:
+ explicit StringResult(txResultRecycler* aRecycler);
+ StringResult(const nsAString& aValue, txResultRecycler* aRecycler);
+
+ TX_DECL_EXPRRESULT
+
+ nsString mValue;
+};
+
+#endif
diff --git a/dom/xslt/xpath/txFilterExpr.cpp b/dom/xslt/xpath/txFilterExpr.cpp
new file mode 100644
index 0000000000..f632683290
--- /dev/null
+++ b/dom/xslt/xpath/txFilterExpr.cpp
@@ -0,0 +1,88 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txExpr.h"
+#include "txNodeSet.h"
+#include "txIXPathContext.h"
+
+using mozilla::Unused;
+using mozilla::WrapUnique;
+
+//-- Implementation of FilterExpr --/
+
+//-----------------------------/
+//- Virtual methods from Expr -/
+//-----------------------------/
+
+/**
+ * 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 ProcessorState containing the stack information needed
+ * for evaluation
+ * @return the result of the evaluation
+ * @see Expr
+ **/
+nsresult FilterExpr::evaluate(txIEvalContext* aContext,
+ txAExprResult** aResult) {
+ *aResult = nullptr;
+
+ RefPtr<txAExprResult> exprRes;
+ nsresult rv = expr->evaluate(aContext, getter_AddRefs(exprRes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ NS_ENSURE_TRUE(exprRes->getResultType() == txAExprResult::NODESET,
+ NS_ERROR_XSLT_NODESET_EXPECTED);
+
+ RefPtr<txNodeSet> nodes =
+ static_cast<txNodeSet*>(static_cast<txAExprResult*>(exprRes));
+ // null out exprRes so that we can test for shared-ness
+ exprRes = nullptr;
+
+ RefPtr<txNodeSet> nonShared;
+ rv = aContext->recycler()->getNonSharedNodeSet(nodes,
+ getter_AddRefs(nonShared));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = evaluatePredicates(nonShared, aContext);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ *aResult = nonShared;
+ NS_ADDREF(*aResult);
+
+ return NS_OK;
+} //-- evaluate
+
+TX_IMPL_EXPR_STUBS_BASE(FilterExpr, NODESET_RESULT)
+
+Expr* FilterExpr::getSubExprAt(uint32_t aPos) {
+ if (aPos == 0) {
+ return expr.get();
+ }
+ return PredicateList::getSubExprAt(aPos - 1);
+}
+
+void FilterExpr::setSubExprAt(uint32_t aPos, Expr* aExpr) {
+ if (aPos == 0) {
+ Unused << expr.release();
+ expr = WrapUnique(aExpr);
+ } else {
+ PredicateList::setSubExprAt(aPos - 1, aExpr);
+ }
+}
+
+bool FilterExpr::isSensitiveTo(ContextSensitivity aContext) {
+ return expr->isSensitiveTo(aContext) ||
+ PredicateList::isSensitiveTo(aContext);
+}
+
+#ifdef TX_TO_STRING
+void FilterExpr::toString(nsAString& str) {
+ if (expr)
+ expr->toString(str);
+ else
+ str.AppendLiteral("null");
+ PredicateList::toString(str);
+}
+#endif
diff --git a/dom/xslt/xpath/txForwardContext.cpp b/dom/xslt/xpath/txForwardContext.cpp
new file mode 100644
index 0000000000..44b53fefbc
--- /dev/null
+++ b/dom/xslt/xpath/txForwardContext.cpp
@@ -0,0 +1,50 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txForwardContext.h"
+#include "txNodeSet.h"
+
+const txXPathNode& txForwardContext::getContextNode() { return mContextNode; }
+
+uint32_t txForwardContext::size() { return (uint32_t)mContextSet->size(); }
+
+uint32_t txForwardContext::position() {
+ int32_t pos = mContextSet->indexOf(mContextNode);
+ NS_ASSERTION(pos >= 0, "Context is not member of context node list.");
+ return (uint32_t)(pos + 1);
+}
+
+nsresult txForwardContext::getVariable(int32_t aNamespace, nsAtom* aLName,
+ txAExprResult*& aResult) {
+ NS_ASSERTION(mInner, "mInner is null!!!");
+ return mInner->getVariable(aNamespace, aLName, aResult);
+}
+
+nsresult txForwardContext::isStripSpaceAllowed(const txXPathNode& aNode,
+ bool& aAllowed) {
+ NS_ASSERTION(mInner, "mInner is null!!!");
+ return mInner->isStripSpaceAllowed(aNode, aAllowed);
+}
+
+void* txForwardContext::getPrivateContext() {
+ NS_ASSERTION(mInner, "mInner is null!!!");
+ return mInner->getPrivateContext();
+}
+
+txResultRecycler* txForwardContext::recycler() {
+ NS_ASSERTION(mInner, "mInner is null!!!");
+ return mInner->recycler();
+}
+
+void txForwardContext::receiveError(const nsAString& aMsg, nsresult aRes) {
+ NS_ASSERTION(mInner, "mInner is null!!!");
+#ifdef DEBUG
+ nsAutoString error(u"forwarded error: "_ns);
+ error.Append(aMsg);
+ mInner->receiveError(error, aRes);
+#else
+ mInner->receiveError(aMsg, aRes);
+#endif
+}
diff --git a/dom/xslt/xpath/txForwardContext.h b/dom/xslt/xpath/txForwardContext.h
new file mode 100644
index 0000000000..447f2fbfc1
--- /dev/null
+++ b/dom/xslt/xpath/txForwardContext.h
@@ -0,0 +1,28 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef __TX_XPATH_CONTEXT
+#define __TX_XPATH_CONTEXT
+
+#include "txIXPathContext.h"
+#include "txNodeSet.h"
+
+class txForwardContext : public txIEvalContext {
+ public:
+ txForwardContext(txIMatchContext* aContext, const txXPathNode& aContextNode,
+ txNodeSet* aContextNodeSet)
+ : mInner(aContext),
+ mContextNode(aContextNode),
+ mContextSet(aContextNodeSet) {}
+
+ TX_DECL_EVAL_CONTEXT;
+
+ private:
+ txIMatchContext* mInner;
+ const txXPathNode& mContextNode;
+ RefPtr<txNodeSet> mContextSet;
+};
+
+#endif // __TX_XPATH_CONTEXT
diff --git a/dom/xslt/xpath/txFunctionCall.cpp b/dom/xslt/xpath/txFunctionCall.cpp
new file mode 100644
index 0000000000..17a325e2ad
--- /dev/null
+++ b/dom/xslt/xpath/txFunctionCall.cpp
@@ -0,0 +1,110 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txExpr.h"
+#include "nsAtom.h"
+#include "txIXPathContext.h"
+#include "txNodeSet.h"
+
+#ifdef TX_TO_STRING
+# include "nsReadableUtils.h"
+#endif
+
+/**
+ * This class represents a FunctionCall as defined by the XSL Working Draft
+ **/
+
+//------------------/
+//- Public Methods -/
+//------------------/
+
+/*
+ * Evaluates the given Expression and converts its result to a number.
+ */
+// static
+nsresult FunctionCall::evaluateToNumber(Expr* aExpr, txIEvalContext* aContext,
+ double* aResult) {
+ NS_ASSERTION(aExpr, "missing expression");
+ RefPtr<txAExprResult> exprResult;
+ nsresult rv = aExpr->evaluate(aContext, getter_AddRefs(exprResult));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ *aResult = exprResult->numberValue();
+
+ return NS_OK;
+}
+
+/*
+ * Evaluates the given Expression and converts its result to a NodeSet.
+ * If the result is not a NodeSet nullptr is returned.
+ */
+nsresult FunctionCall::evaluateToNodeSet(Expr* aExpr, txIEvalContext* aContext,
+ txNodeSet** aResult) {
+ NS_ASSERTION(aExpr, "Missing expression to evaluate");
+ *aResult = nullptr;
+
+ RefPtr<txAExprResult> exprRes;
+ nsresult rv = aExpr->evaluate(aContext, getter_AddRefs(exprRes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (exprRes->getResultType() != txAExprResult::NODESET) {
+ aContext->receiveError(u"NodeSet expected as argument"_ns,
+ NS_ERROR_XSLT_NODESET_EXPECTED);
+ return NS_ERROR_XSLT_NODESET_EXPECTED;
+ }
+
+ *aResult = static_cast<txNodeSet*>(static_cast<txAExprResult*>(exprRes));
+ NS_ADDREF(*aResult);
+
+ return NS_OK;
+}
+
+bool FunctionCall::requireParams(int32_t aParamCountMin, int32_t aParamCountMax,
+ txIEvalContext* aContext) {
+ int32_t argc = mParams.Length();
+ if (argc < aParamCountMin || (aParamCountMax > -1 && argc > aParamCountMax)) {
+ nsAutoString err(u"invalid number of parameters for function"_ns);
+#ifdef TX_TO_STRING
+ err.AppendLiteral(": ");
+ toString(err);
+#endif
+ aContext->receiveError(err, NS_ERROR_XPATH_INVALID_ARG);
+
+ return false;
+ }
+
+ return true;
+}
+
+Expr* FunctionCall::getSubExprAt(uint32_t aPos) {
+ return mParams.SafeElementAt(aPos);
+}
+
+void FunctionCall::setSubExprAt(uint32_t aPos, Expr* aExpr) {
+ NS_ASSERTION(aPos < mParams.Length(), "setting bad subexpression index");
+ mParams[aPos] = aExpr;
+}
+
+bool FunctionCall::argsSensitiveTo(ContextSensitivity aContext) {
+ uint32_t i, len = mParams.Length();
+ for (i = 0; i < len; ++i) {
+ if (mParams[i]->isSensitiveTo(aContext)) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+#ifdef TX_TO_STRING
+void FunctionCall::toString(nsAString& aDest) {
+ appendName(aDest);
+ aDest.AppendLiteral("(");
+ StringJoinAppend(
+ aDest, u","_ns, mParams,
+ [](nsAString& dest, const auto& param) { param->toString(dest); });
+ aDest.Append(char16_t(')'));
+}
+#endif
diff --git a/dom/xslt/xpath/txIXPathContext.h b/dom/xslt/xpath/txIXPathContext.h
new file mode 100644
index 0000000000..8d5b5df4be
--- /dev/null
+++ b/dom/xslt/xpath/txIXPathContext.h
@@ -0,0 +1,132 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef __TX_I_XPATH_CONTEXT
+#define __TX_I_XPATH_CONTEXT
+
+#include "nscore.h"
+#include "nsISupportsImpl.h"
+#include "nsStringFwd.h"
+
+class FunctionCall;
+class nsAtom;
+class txAExprResult;
+class txResultRecycler;
+class txXPathNode;
+
+/*
+ * txIParseContext
+ *
+ * This interface describes the context needed to create
+ * XPath Expressions and XSLT Patters.
+ * (not completely though. key() requires the ProcessorState, which is
+ * not part of this interface.)
+ */
+
+class txIParseContext {
+ public:
+ virtual ~txIParseContext() = default;
+
+ /*
+ * Return a namespaceID for a given prefix.
+ */
+ virtual nsresult resolveNamespacePrefix(nsAtom* aPrefix, int32_t& aID) = 0;
+
+ /*
+ * Create a FunctionCall, needed for extension function calls and
+ * XSLT. XPath function calls are resolved by the Parser.
+ */
+ virtual nsresult resolveFunctionCall(nsAtom* aName, int32_t aID,
+ FunctionCall** aFunction) = 0;
+
+ /**
+ * Should nametests parsed in this context be case-sensitive
+ */
+ virtual bool caseInsensitiveNameTests() = 0;
+
+ /*
+ * Callback to be used by the Parser if errors are detected.
+ */
+ virtual void SetErrorOffset(uint32_t aOffset) = 0;
+
+ enum Allowed { KEY_FUNCTION = 1 << 0 };
+ virtual bool allowed(Allowed aAllowed) { return true; }
+};
+
+/*
+ * txIMatchContext
+ *
+ * Interface used for matching XSLT Patters.
+ * This is the part of txIEvalContext (see below), that is independent
+ * of the context node when evaluating a XPath expression, too.
+ * When evaluating a XPath expression, |txIMatchContext|s are used
+ * to transport the information from Step to Step.
+ */
+class txIMatchContext {
+ public:
+ virtual ~txIMatchContext() = default;
+
+ /*
+ * Return the ExprResult associated with the variable with the
+ * given namespace and local name.
+ */
+ virtual nsresult getVariable(int32_t aNamespace, nsAtom* aLName,
+ txAExprResult*& aResult) = 0;
+
+ /*
+ * Is whitespace stripping allowed for the given node?
+ * See http://www.w3.org/TR/xslt#strip
+ */
+ virtual nsresult isStripSpaceAllowed(const txXPathNode& aNode,
+ bool& aAllowed) = 0;
+
+ /**
+ * Returns a pointer to the private context
+ */
+ virtual void* getPrivateContext() = 0;
+
+ virtual txResultRecycler* recycler() = 0;
+
+ /*
+ * Callback to be used by the expression/pattern if errors are detected.
+ */
+ virtual void receiveError(const nsAString& aMsg, nsresult aRes) = 0;
+};
+
+#define TX_DECL_MATCH_CONTEXT \
+ nsresult getVariable(int32_t aNamespace, nsAtom* aLName, \
+ txAExprResult*& aResult) override; \
+ nsresult isStripSpaceAllowed(const txXPathNode& aNode, bool& aAllowed) \
+ override; \
+ void* getPrivateContext() override; \
+ txResultRecycler* recycler() override; \
+ void receiveError(const nsAString& aMsg, nsresult aRes) override
+
+class txIEvalContext : public txIMatchContext {
+ public:
+ /*
+ * Get the context node.
+ */
+ virtual const txXPathNode& getContextNode() = 0;
+
+ /*
+ * Get the size of the context node set.
+ */
+ virtual uint32_t size() = 0;
+
+ /*
+ * Get the position of the context node in the context node set,
+ * starting with 1.
+ */
+ virtual uint32_t position() = 0;
+};
+
+#define TX_DECL_EVAL_CONTEXT \
+ TX_DECL_MATCH_CONTEXT; \
+ const txXPathNode& getContextNode() override; \
+ uint32_t size() override; \
+ uint32_t position() override
+
+#endif // __TX_I_XPATH_CONTEXT
diff --git a/dom/xslt/xpath/txLiteralExpr.cpp b/dom/xslt/xpath/txLiteralExpr.cpp
new file mode 100644
index 0000000000..93ea2c8f1d
--- /dev/null
+++ b/dom/xslt/xpath/txLiteralExpr.cpp
@@ -0,0 +1,74 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txExpr.h"
+
+nsresult txLiteralExpr::evaluate(txIEvalContext* aContext,
+ txAExprResult** aResult) {
+ NS_ENSURE_TRUE(mValue, NS_ERROR_OUT_OF_MEMORY);
+
+ *aResult = mValue;
+ NS_ADDREF(*aResult);
+
+ return NS_OK;
+}
+
+static Expr::ResultType resultTypes[] = {
+ Expr::NODESET_RESULT, // NODESET
+ Expr::BOOLEAN_RESULT, // BOOLEAN
+ Expr::NUMBER_RESULT, // NUMBER
+ Expr::STRING_RESULT, // STRING
+ Expr::RTF_RESULT // RESULT_TREE_FRAGMENT
+};
+
+Expr::ResultType txLiteralExpr::getReturnType() {
+ return resultTypes[mValue->getResultType()];
+}
+
+Expr* txLiteralExpr::getSubExprAt(uint32_t aPos) { return nullptr; }
+void txLiteralExpr::setSubExprAt(uint32_t aPos, Expr* aExpr) {
+ MOZ_ASSERT_UNREACHABLE("setting bad subexpression index");
+}
+
+bool txLiteralExpr::isSensitiveTo(ContextSensitivity aContext) { return false; }
+
+#ifdef TX_TO_STRING
+void txLiteralExpr::toString(nsAString& aStr) {
+ switch (mValue->getResultType()) {
+ case txAExprResult::NODESET: {
+ aStr.AppendLiteral(" { Nodeset literal } ");
+ return;
+ }
+ case txAExprResult::BOOLEAN: {
+ if (mValue->booleanValue()) {
+ aStr.AppendLiteral("true()");
+ } else {
+ aStr.AppendLiteral("false()");
+ }
+ return;
+ }
+ case txAExprResult::NUMBER: {
+ txDouble::toString(mValue->numberValue(), aStr);
+ return;
+ }
+ case txAExprResult::STRING: {
+ StringResult* strRes =
+ static_cast<StringResult*>(static_cast<txAExprResult*>(mValue));
+ char16_t ch = '\'';
+ if (strRes->mValue.Contains(ch)) {
+ ch = '\"';
+ }
+ aStr.Append(ch);
+ aStr.Append(strRes->mValue);
+ aStr.Append(ch);
+ return;
+ }
+ case txAExprResult::RESULT_TREE_FRAGMENT: {
+ aStr.AppendLiteral(" { RTF literal } ");
+ return;
+ }
+ }
+}
+#endif
diff --git a/dom/xslt/xpath/txLocationStep.cpp b/dom/xslt/xpath/txLocationStep.cpp
new file mode 100644
index 0000000000..c10d9e8cb1
--- /dev/null
+++ b/dom/xslt/xpath/txLocationStep.cpp
@@ -0,0 +1,308 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+ Implementation of an XPath LocationStep
+*/
+
+#include "txExpr.h"
+#include "txIXPathContext.h"
+#include "txNodeSet.h"
+#include "txXPathTreeWalker.h"
+
+//-----------------------------/
+//- Virtual methods from Expr -/
+//-----------------------------/
+
+/**
+ * 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 ProcessorState containing the stack information needed
+ * for evaluation
+ * @return the result of the evaluation
+ * @see Expr
+ **/
+nsresult LocationStep::evaluate(txIEvalContext* aContext,
+ txAExprResult** aResult) {
+ NS_ASSERTION(aContext, "internal error");
+ *aResult = nullptr;
+
+ RefPtr<txNodeSet> nodes;
+ nsresult rv = aContext->recycler()->getNodeSet(getter_AddRefs(nodes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ txXPathTreeWalker walker(aContext->getContextNode());
+
+ switch (mAxisIdentifier) {
+ case ANCESTOR_AXIS: {
+ if (!walker.moveToParent()) {
+ break;
+ }
+ [[fallthrough]];
+ }
+ case ANCESTOR_OR_SELF_AXIS: {
+ nodes->setReverse();
+
+ do {
+ rv = appendIfMatching(walker, aContext, nodes);
+ NS_ENSURE_SUCCESS(rv, rv);
+ } while (walker.moveToParent());
+
+ break;
+ }
+ case ATTRIBUTE_AXIS: {
+ if (!walker.moveToFirstAttribute()) {
+ break;
+ }
+
+ do {
+ rv = appendIfMatching(walker, aContext, nodes);
+ NS_ENSURE_SUCCESS(rv, rv);
+ } while (walker.moveToNextAttribute());
+ break;
+ }
+ case DESCENDANT_OR_SELF_AXIS: {
+ rv = appendIfMatching(walker, aContext, nodes);
+ NS_ENSURE_SUCCESS(rv, rv);
+ [[fallthrough]];
+ }
+ case DESCENDANT_AXIS: {
+ rv = appendMatchingDescendants(walker, aContext, nodes);
+ NS_ENSURE_SUCCESS(rv, rv);
+ break;
+ }
+ case FOLLOWING_AXIS: {
+ if (txXPathNodeUtils::isAttribute(walker.getCurrentPosition())) {
+ walker.moveToParent();
+ rv = appendMatchingDescendants(walker, aContext, nodes);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ bool cont = true;
+ while (!walker.moveToNextSibling()) {
+ if (!walker.moveToParent()) {
+ cont = false;
+ break;
+ }
+ }
+ while (cont) {
+ rv = appendIfMatching(walker, aContext, nodes);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = appendMatchingDescendants(walker, aContext, nodes);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ while (!walker.moveToNextSibling()) {
+ if (!walker.moveToParent()) {
+ cont = false;
+ break;
+ }
+ }
+ }
+ break;
+ }
+ case FOLLOWING_SIBLING_AXIS: {
+ while (walker.moveToNextSibling()) {
+ rv = appendIfMatching(walker, aContext, nodes);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ break;
+ }
+ case NAMESPACE_AXIS: //-- not yet implemented
+#if 0
+ // XXX DEBUG OUTPUT
+ cout << "namespace axis not yet implemented"<<endl;
+#endif
+ break;
+ case PARENT_AXIS: {
+ if (walker.moveToParent()) {
+ rv = appendIfMatching(walker, aContext, nodes);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ break;
+ }
+ case PRECEDING_AXIS: {
+ nodes->setReverse();
+
+ bool cont = true;
+ while (!walker.moveToPreviousSibling()) {
+ if (!walker.moveToParent()) {
+ cont = false;
+ break;
+ }
+ }
+ while (cont) {
+ rv = appendMatchingDescendantsRev(walker, aContext, nodes);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = appendIfMatching(walker, aContext, nodes);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ while (!walker.moveToPreviousSibling()) {
+ if (!walker.moveToParent()) {
+ cont = false;
+ break;
+ }
+ }
+ }
+ break;
+ }
+ case PRECEDING_SIBLING_AXIS: {
+ nodes->setReverse();
+
+ while (walker.moveToPreviousSibling()) {
+ rv = appendIfMatching(walker, aContext, nodes);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ break;
+ }
+ case SELF_AXIS: {
+ rv = appendIfMatching(walker, aContext, nodes);
+ NS_ENSURE_SUCCESS(rv, rv);
+ break;
+ }
+ default: // Children Axis
+ {
+ if (!walker.moveToFirstChild()) {
+ break;
+ }
+
+ do {
+ rv = appendIfMatching(walker, aContext, nodes);
+ NS_ENSURE_SUCCESS(rv, rv);
+ } while (walker.moveToNextSibling());
+ break;
+ }
+ }
+
+ // Apply predicates
+ if (!isEmpty()) {
+ rv = evaluatePredicates(nodes, aContext);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ nodes->unsetReverse();
+
+ NS_ADDREF(*aResult = nodes);
+
+ return NS_OK;
+}
+
+nsresult LocationStep::appendIfMatching(const txXPathTreeWalker& aWalker,
+ txIMatchContext* aContext,
+ txNodeSet* aNodes) {
+ bool matched;
+ const txXPathNode& child = aWalker.getCurrentPosition();
+ nsresult rv = mNodeTest->matches(child, aContext, matched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (matched) {
+ aNodes->append(child);
+ }
+ return NS_OK;
+}
+
+nsresult LocationStep::appendMatchingDescendants(
+ const txXPathTreeWalker& aWalker, txIMatchContext* aContext,
+ txNodeSet* aNodes) {
+ txXPathTreeWalker walker(aWalker);
+ if (!walker.moveToFirstChild()) {
+ return NS_OK;
+ }
+
+ do {
+ nsresult rv = appendIfMatching(walker, aContext, aNodes);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = appendMatchingDescendants(walker, aContext, aNodes);
+ NS_ENSURE_SUCCESS(rv, rv);
+ } while (walker.moveToNextSibling());
+
+ return NS_OK;
+}
+
+nsresult LocationStep::appendMatchingDescendantsRev(
+ const txXPathTreeWalker& aWalker, txIMatchContext* aContext,
+ txNodeSet* aNodes) {
+ txXPathTreeWalker walker(aWalker);
+ if (!walker.moveToLastChild()) {
+ return NS_OK;
+ }
+
+ do {
+ nsresult rv = appendMatchingDescendantsRev(walker, aContext, aNodes);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = appendIfMatching(walker, aContext, aNodes);
+ NS_ENSURE_SUCCESS(rv, rv);
+ } while (walker.moveToPreviousSibling());
+
+ return NS_OK;
+}
+
+Expr::ExprType LocationStep::getType() { return LOCATIONSTEP_EXPR; }
+
+TX_IMPL_EXPR_STUBS_BASE(LocationStep, NODESET_RESULT)
+
+Expr* LocationStep::getSubExprAt(uint32_t aPos) {
+ return PredicateList::getSubExprAt(aPos);
+}
+
+void LocationStep::setSubExprAt(uint32_t aPos, Expr* aExpr) {
+ PredicateList::setSubExprAt(aPos, aExpr);
+}
+
+bool LocationStep::isSensitiveTo(ContextSensitivity aContext) {
+ return (aContext & NODE_CONTEXT) || mNodeTest->isSensitiveTo(aContext) ||
+ PredicateList::isSensitiveTo(aContext);
+}
+
+#ifdef TX_TO_STRING
+void LocationStep::toString(nsAString& str) {
+ switch (mAxisIdentifier) {
+ case ANCESTOR_AXIS:
+ str.AppendLiteral("ancestor::");
+ break;
+ case ANCESTOR_OR_SELF_AXIS:
+ str.AppendLiteral("ancestor-or-self::");
+ break;
+ case ATTRIBUTE_AXIS:
+ str.Append(char16_t('@'));
+ break;
+ case DESCENDANT_AXIS:
+ str.AppendLiteral("descendant::");
+ break;
+ case DESCENDANT_OR_SELF_AXIS:
+ str.AppendLiteral("descendant-or-self::");
+ break;
+ case FOLLOWING_AXIS:
+ str.AppendLiteral("following::");
+ break;
+ case FOLLOWING_SIBLING_AXIS:
+ str.AppendLiteral("following-sibling::");
+ break;
+ case NAMESPACE_AXIS:
+ str.AppendLiteral("namespace::");
+ break;
+ case PARENT_AXIS:
+ str.AppendLiteral("parent::");
+ break;
+ case PRECEDING_AXIS:
+ str.AppendLiteral("preceding::");
+ break;
+ case PRECEDING_SIBLING_AXIS:
+ str.AppendLiteral("preceding-sibling::");
+ break;
+ case SELF_AXIS:
+ str.AppendLiteral("self::");
+ break;
+ default:
+ break;
+ }
+ NS_ASSERTION(mNodeTest, "mNodeTest is null, that's verboten");
+ mNodeTest->toString(str);
+
+ PredicateList::toString(str);
+}
+#endif
diff --git a/dom/xslt/xpath/txMozillaXPathTreeWalker.cpp b/dom/xslt/xpath/txMozillaXPathTreeWalker.cpp
new file mode 100644
index 0000000000..8150d7307e
--- /dev/null
+++ b/dom/xslt/xpath/txMozillaXPathTreeWalker.cpp
@@ -0,0 +1,674 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txXPathTreeWalker.h"
+#include "nsAtom.h"
+#include "nsINode.h"
+#include "nsPrintfCString.h"
+#include "nsReadableUtils.h"
+#include "nsString.h"
+#include "nsTextFragment.h"
+#include "txXMLUtils.h"
+#include "txLog.h"
+#include "nsUnicharUtils.h"
+#include "nsAttrName.h"
+#include "nsNameSpaceManager.h"
+#include "nsTArray.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/dom/Attr.h"
+#include "mozilla/dom/CharacterData.h"
+#include "mozilla/dom/Element.h"
+#include <stdint.h>
+#include <algorithm>
+
+using namespace mozilla::dom;
+using mozilla::Maybe;
+
+txXPathTreeWalker::txXPathTreeWalker(const txXPathTreeWalker& aOther) = default;
+
+txXPathTreeWalker::txXPathTreeWalker(const txXPathNode& aNode)
+ : mPosition(aNode) {}
+
+void txXPathTreeWalker::moveToRoot() {
+ if (mPosition.isDocument()) {
+ return;
+ }
+
+ Document* root = mPosition.mNode->GetUncomposedDoc();
+ if (root) {
+ mPosition.mIndex = txXPathNode::eDocument;
+ mPosition.mNode = root;
+ } else {
+ nsINode* rootNode = mPosition.Root();
+
+ NS_ASSERTION(rootNode->IsContent(), "root of subtree wasn't an nsIContent");
+
+ mPosition.mIndex = txXPathNode::eContent;
+ mPosition.mNode = rootNode;
+ }
+}
+
+bool txXPathTreeWalker::moveToElementById(const nsAString& aID) {
+ if (aID.IsEmpty()) {
+ return false;
+ }
+
+ Document* doc = mPosition.mNode->GetUncomposedDoc();
+
+ nsCOMPtr<nsIContent> content;
+ if (doc) {
+ content = doc->GetElementById(aID);
+ } else {
+ // We're in a disconnected subtree, search only that subtree.
+ nsINode* rootNode = mPosition.Root();
+
+ NS_ASSERTION(rootNode->IsContent(), "root of subtree wasn't an nsIContent");
+
+ content =
+ nsContentUtils::MatchElementId(static_cast<nsIContent*>(rootNode), aID);
+ }
+
+ if (!content) {
+ return false;
+ }
+
+ mPosition.mIndex = txXPathNode::eContent;
+ mPosition.mNode = content;
+
+ return true;
+}
+
+bool txXPathTreeWalker::moveToFirstAttribute() {
+ if (!mPosition.isContent()) {
+ return false;
+ }
+
+ return moveToValidAttribute(0);
+}
+
+bool txXPathTreeWalker::moveToNextAttribute() {
+ // XXX an assertion should be enough here with the current code
+ if (!mPosition.isAttribute()) {
+ return false;
+ }
+
+ return moveToValidAttribute(mPosition.mIndex + 1);
+}
+
+bool txXPathTreeWalker::moveToValidAttribute(uint32_t aStartIndex) {
+ NS_ASSERTION(!mPosition.isDocument(), "documents doesn't have attrs");
+
+ if (!mPosition.Content()->IsElement()) {
+ return false;
+ }
+
+ Element* element = mPosition.Content()->AsElement();
+ uint32_t total = element->GetAttrCount();
+ if (aStartIndex >= total) {
+ return false;
+ }
+
+ uint32_t index;
+ for (index = aStartIndex; index < total; ++index) {
+ const nsAttrName* name = element->GetAttrNameAt(index);
+
+ // We need to ignore XMLNS attributes.
+ if (name->NamespaceID() != kNameSpaceID_XMLNS) {
+ mPosition.mIndex = index;
+
+ return true;
+ }
+ }
+ return false;
+}
+
+bool txXPathTreeWalker::moveToNamedAttribute(nsAtom* aLocalName,
+ int32_t aNSID) {
+ if (!mPosition.isContent() || !mPosition.Content()->IsElement()) {
+ return false;
+ }
+
+ Element* element = mPosition.Content()->AsElement();
+
+ const nsAttrName* name;
+ uint32_t i;
+ for (i = 0; (name = element->GetAttrNameAt(i)); ++i) {
+ if (name->Equals(aLocalName, aNSID)) {
+ mPosition.mIndex = i;
+
+ return true;
+ }
+ }
+ return false;
+}
+
+bool txXPathTreeWalker::moveToFirstChild() {
+ if (mPosition.isAttribute()) {
+ return false;
+ }
+
+ nsIContent* child = mPosition.mNode->GetFirstChild();
+ if (!child) {
+ return false;
+ }
+ mPosition.mIndex = txXPathNode::eContent;
+ mPosition.mNode = child;
+
+ return true;
+}
+
+bool txXPathTreeWalker::moveToLastChild() {
+ if (mPosition.isAttribute()) {
+ return false;
+ }
+
+ nsIContent* child = mPosition.mNode->GetLastChild();
+ if (!child) {
+ return false;
+ }
+
+ mPosition.mIndex = txXPathNode::eContent;
+ mPosition.mNode = child;
+
+ return true;
+}
+
+bool txXPathTreeWalker::moveToNextSibling() {
+ if (!mPosition.isContent()) {
+ return false;
+ }
+
+ nsINode* sibling = mPosition.mNode->GetNextSibling();
+ if (!sibling) {
+ return false;
+ }
+
+ mPosition.mNode = sibling;
+
+ return true;
+}
+
+bool txXPathTreeWalker::moveToPreviousSibling() {
+ if (!mPosition.isContent()) {
+ return false;
+ }
+
+ nsINode* sibling = mPosition.mNode->GetPreviousSibling();
+ if (!sibling) {
+ return false;
+ }
+
+ mPosition.mNode = sibling;
+
+ return true;
+}
+
+bool txXPathTreeWalker::moveToParent() {
+ if (mPosition.isDocument()) {
+ return false;
+ }
+
+ if (mPosition.isAttribute()) {
+ mPosition.mIndex = txXPathNode::eContent;
+
+ return true;
+ }
+
+ nsINode* parent = mPosition.mNode->GetParentNode();
+ if (!parent) {
+ return false;
+ }
+
+ mPosition.mIndex = mPosition.mNode->GetParent() ? txXPathNode::eContent
+ : txXPathNode::eDocument;
+ mPosition.mNode = parent;
+
+ return true;
+}
+
+txXPathNode::txXPathNode(const txXPathNode& aNode)
+ : mNode(aNode.mNode),
+ mRefCountRoot(aNode.mRefCountRoot),
+ mIndex(aNode.mIndex) {
+ MOZ_COUNT_CTOR(txXPathNode);
+ if (mRefCountRoot) {
+ NS_ADDREF(Root());
+ }
+}
+
+txXPathNode::~txXPathNode() {
+ MOZ_COUNT_DTOR(txXPathNode);
+ if (mRefCountRoot) {
+ nsINode* root = Root();
+ NS_RELEASE(root);
+ }
+}
+
+/* static */
+bool txXPathNodeUtils::getAttr(const txXPathNode& aNode, nsAtom* aLocalName,
+ int32_t aNSID, nsAString& aValue) {
+ if (aNode.isDocument() || aNode.isAttribute() ||
+ !aNode.Content()->IsElement()) {
+ return false;
+ }
+
+ return aNode.Content()->AsElement()->GetAttr(aNSID, aLocalName, aValue);
+}
+
+/* static */
+already_AddRefed<nsAtom> txXPathNodeUtils::getLocalName(
+ const txXPathNode& aNode) {
+ if (aNode.isDocument()) {
+ return nullptr;
+ }
+
+ if (aNode.isContent()) {
+ if (aNode.mNode->IsElement()) {
+ RefPtr<nsAtom> localName = aNode.Content()->NodeInfo()->NameAtom();
+ return localName.forget();
+ }
+
+ if (aNode.mNode->IsProcessingInstruction()) {
+ return NS_Atomize(aNode.mNode->NodeName());
+ }
+
+ return nullptr;
+ }
+
+ // This is an attribute node, so we necessarily come from an element.
+ RefPtr<nsAtom> localName =
+ aNode.Content()->AsElement()->GetAttrNameAt(aNode.mIndex)->LocalName();
+
+ return localName.forget();
+}
+
+nsAtom* txXPathNodeUtils::getPrefix(const txXPathNode& aNode) {
+ if (aNode.isDocument()) {
+ return nullptr;
+ }
+
+ if (aNode.isContent()) {
+ // All other nsIContent node types but elements have a null prefix
+ // which is what we want here.
+ return aNode.Content()->NodeInfo()->GetPrefixAtom();
+ }
+
+ return aNode.Content()->AsElement()->GetAttrNameAt(aNode.mIndex)->GetPrefix();
+}
+
+/* static */
+void txXPathNodeUtils::getLocalName(const txXPathNode& aNode,
+ nsAString& aLocalName) {
+ if (aNode.isDocument()) {
+ aLocalName.Truncate();
+
+ return;
+ }
+
+ if (aNode.isContent()) {
+ if (aNode.mNode->IsElement()) {
+ mozilla::dom::NodeInfo* nodeInfo = aNode.Content()->NodeInfo();
+ nodeInfo->GetName(aLocalName);
+ return;
+ }
+
+ if (aNode.mNode->IsProcessingInstruction()) {
+ // PIs don't have a nodeinfo but do have a name
+ // XXXbz Not actually true, but this function looks like it wants
+ // different things from elements and PIs for "local name"...
+ aLocalName = aNode.mNode->NodeName();
+ return;
+ }
+
+ aLocalName.Truncate();
+
+ return;
+ }
+
+ aNode.Content()
+ ->AsElement()
+ ->GetAttrNameAt(aNode.mIndex)
+ ->LocalName()
+ ->ToString(aLocalName);
+
+ // Check for html
+ if (aNode.Content()->NodeInfo()->NamespaceEquals(kNameSpaceID_None) &&
+ aNode.Content()->IsHTMLElement()) {
+ nsContentUtils::ASCIIToUpper(aLocalName);
+ }
+}
+
+/* static */
+void txXPathNodeUtils::getNodeName(const txXPathNode& aNode, nsAString& aName) {
+ if (aNode.isDocument()) {
+ aName.Truncate();
+
+ return;
+ }
+
+ if (aNode.isContent()) {
+ // Elements and PIs have a name
+ if (aNode.mNode->IsElement() ||
+ aNode.mNode->NodeType() == nsINode::PROCESSING_INSTRUCTION_NODE) {
+ aName = aNode.Content()->NodeName();
+ return;
+ }
+
+ aName.Truncate();
+
+ return;
+ }
+
+ aNode.Content()
+ ->AsElement()
+ ->GetAttrNameAt(aNode.mIndex)
+ ->GetQualifiedName(aName);
+}
+
+/* static */
+int32_t txXPathNodeUtils::getNamespaceID(const txXPathNode& aNode) {
+ if (aNode.isDocument()) {
+ return kNameSpaceID_None;
+ }
+
+ if (aNode.isContent()) {
+ return aNode.Content()->GetNameSpaceID();
+ }
+
+ return aNode.Content()
+ ->AsElement()
+ ->GetAttrNameAt(aNode.mIndex)
+ ->NamespaceID();
+}
+
+/* static */
+void txXPathNodeUtils::getNamespaceURI(const txXPathNode& aNode,
+ nsAString& aURI) {
+ nsNameSpaceManager::GetInstance()->GetNameSpaceURI(getNamespaceID(aNode),
+ aURI);
+}
+
+/* static */
+uint16_t txXPathNodeUtils::getNodeType(const txXPathNode& aNode) {
+ if (aNode.isDocument()) {
+ return txXPathNodeType::DOCUMENT_NODE;
+ }
+
+ if (aNode.isContent()) {
+ return aNode.mNode->NodeType();
+ }
+
+ return txXPathNodeType::ATTRIBUTE_NODE;
+}
+
+/* static */
+void txXPathNodeUtils::appendNodeValue(const txXPathNode& aNode,
+ nsAString& aResult) {
+ if (aNode.isAttribute()) {
+ const nsAttrName* name =
+ aNode.Content()->AsElement()->GetAttrNameAt(aNode.mIndex);
+
+ if (aResult.IsEmpty()) {
+ aNode.Content()->AsElement()->GetAttr(name->NamespaceID(),
+ name->LocalName(), aResult);
+ } else {
+ nsAutoString result;
+ aNode.Content()->AsElement()->GetAttr(name->NamespaceID(),
+ name->LocalName(), result);
+ aResult.Append(result);
+ }
+
+ return;
+ }
+
+ if (aNode.isDocument() || aNode.mNode->IsElement() ||
+ aNode.mNode->IsDocumentFragment()) {
+ nsContentUtils::AppendNodeTextContent(aNode.mNode, true, aResult,
+ mozilla::fallible);
+
+ return;
+ }
+
+ MOZ_ASSERT(aNode.mNode->IsCharacterData());
+ static_cast<CharacterData*>(aNode.Content())->AppendTextTo(aResult);
+}
+
+/* static */
+bool txXPathNodeUtils::isWhitespace(const txXPathNode& aNode) {
+ NS_ASSERTION(aNode.isContent() && isText(aNode), "Wrong type!");
+
+ return aNode.Content()->TextIsOnlyWhitespace();
+}
+
+/* static */
+txXPathNode* txXPathNodeUtils::getOwnerDocument(const txXPathNode& aNode) {
+ return new txXPathNode(aNode.mNode->OwnerDoc());
+}
+
+const char gPrintfFmt[] = "id0x%" PRIxPTR;
+const char gPrintfFmtAttr[] = "id0x%" PRIxPTR "-%010i";
+
+/* static */
+nsresult txXPathNodeUtils::getXSLTId(const txXPathNode& aNode,
+ const txXPathNode& aBase,
+ nsAString& aResult) {
+ uintptr_t nodeid = ((uintptr_t)aNode.mNode) - ((uintptr_t)aBase.mNode);
+ if (!aNode.isAttribute()) {
+ CopyASCIItoUTF16(nsPrintfCString(gPrintfFmt, nodeid), aResult);
+ } else {
+ CopyASCIItoUTF16(nsPrintfCString(gPrintfFmtAttr, nodeid, aNode.mIndex),
+ aResult);
+ }
+
+ return NS_OK;
+}
+
+/* static */
+nsresult txXPathNodeUtils::getBaseURI(const txXPathNode& aNode,
+ nsAString& aURI) {
+ return aNode.mNode->GetBaseURI(aURI);
+}
+
+/* static */
+int txXPathNodeUtils::comparePosition(const txXPathNode& aNode,
+ const txXPathNode& aOtherNode) {
+ // First check for equal nodes or attribute-nodes on the same element.
+ if (aNode.mNode == aOtherNode.mNode) {
+ if (aNode.mIndex == aOtherNode.mIndex) {
+ return 0;
+ }
+
+ NS_ASSERTION(!aNode.isDocument() && !aOtherNode.isDocument(),
+ "documents should always have a set index");
+
+ if (aNode.isContent() ||
+ (!aOtherNode.isContent() && aNode.mIndex < aOtherNode.mIndex)) {
+ return -1;
+ }
+
+ return 1;
+ }
+
+ // Get document for both nodes.
+ Document* document = aNode.mNode->GetUncomposedDoc();
+ Document* otherDocument = aOtherNode.mNode->GetUncomposedDoc();
+
+ // If the nodes have different current documents, compare the document
+ // pointers.
+ if (document != otherDocument) {
+ return document < otherDocument ? -1 : 1;
+ }
+
+ // Now either both nodes are in orphan trees, or they are both in the
+ // same tree.
+
+ // Get parents up the tree.
+ AutoTArray<nsINode*, 8> parents, otherParents;
+ nsINode* node = aNode.mNode;
+ nsINode* otherNode = aOtherNode.mNode;
+ nsINode* parent;
+ nsINode* otherParent;
+ while (node && otherNode) {
+ parent = node->GetParentNode();
+ otherParent = otherNode->GetParentNode();
+
+ // Hopefully this is a common case.
+ if (parent == otherParent) {
+ if (!parent) {
+ // Both node and otherNode are root nodes in respective orphan
+ // tree.
+ return node < otherNode ? -1 : 1;
+ }
+
+ const Maybe<uint32_t> indexOfNode = parent->ComputeIndexOf(node);
+ const Maybe<uint32_t> indexOfOtherNode =
+ parent->ComputeIndexOf(otherNode);
+ if (MOZ_LIKELY(indexOfNode.isSome() && indexOfOtherNode.isSome())) {
+ return *indexOfNode < *indexOfOtherNode ? -1 : 1;
+ }
+ // XXX Keep the odd traditional behavior for now.
+ return indexOfNode.isNothing() && indexOfOtherNode.isSome() ? -1 : 1;
+ }
+
+ parents.AppendElement(node);
+ otherParents.AppendElement(otherNode);
+ node = parent;
+ otherNode = otherParent;
+ }
+
+ while (node) {
+ parents.AppendElement(node);
+ node = node->GetParentNode();
+ }
+ while (otherNode) {
+ otherParents.AppendElement(otherNode);
+ otherNode = otherNode->GetParentNode();
+ }
+
+ // Walk back down along the parent-chains until we find where they split.
+ int32_t total = parents.Length() - 1;
+ int32_t otherTotal = otherParents.Length() - 1;
+ NS_ASSERTION(total != otherTotal, "Can't have same number of parents");
+
+ int32_t lastIndex = std::min(total, otherTotal);
+ int32_t i;
+ parent = nullptr;
+ for (i = 0; i <= lastIndex; ++i) {
+ node = parents.ElementAt(total - i);
+ otherNode = otherParents.ElementAt(otherTotal - i);
+ if (node != otherNode) {
+ if (!parent) {
+ // The two nodes are in different orphan subtrees.
+ NS_ASSERTION(i == 0, "this shouldn't happen");
+ return node < otherNode ? -1 : 1;
+ }
+
+ const Maybe<uint32_t> index = parent->ComputeIndexOf(node);
+ const Maybe<uint32_t> otherIndex = parent->ComputeIndexOf(otherNode);
+ if (MOZ_LIKELY(index.isSome() && otherIndex.isSome())) {
+ NS_ASSERTION(*index != *otherIndex, "invalid index in comparePosition");
+ return *index < *otherIndex ? -1 : 1;
+ }
+ NS_ASSERTION(false, "invalid index in comparePosition");
+ // XXX Keep the odd traditional behavior for now.
+ return index.isNothing() && otherIndex.isSome() ? -1 : 1;
+ }
+
+ parent = node;
+ }
+
+ // One node is a descendant of the other. The one with the shortest
+ // parent-chain is first in the document.
+ return total < otherTotal ? -1 : 1;
+}
+
+/* static */
+txXPathNode* txXPathNativeNode::createXPathNode(nsIContent* aContent,
+ bool aKeepRootAlive) {
+ nsINode* root = aKeepRootAlive ? txXPathNode::RootOf(aContent) : nullptr;
+
+ return new txXPathNode(aContent, txXPathNode::eContent, root);
+}
+
+/* static */
+txXPathNode* txXPathNativeNode::createXPathNode(nsINode* aNode,
+ bool aKeepRootAlive) {
+ uint16_t nodeType = aNode->NodeType();
+ if (nodeType == nsINode::ATTRIBUTE_NODE) {
+ auto* attr = static_cast<Attr*>(aNode);
+
+ NodeInfo* nodeInfo = attr->NodeInfo();
+ Element* parent = attr->GetElement();
+ if (!parent) {
+ return nullptr;
+ }
+
+ nsINode* root = aKeepRootAlive ? txXPathNode::RootOf(parent) : nullptr;
+
+ uint32_t i, total = parent->GetAttrCount();
+ for (i = 0; i < total; ++i) {
+ const nsAttrName* name = parent->GetAttrNameAt(i);
+ if (nodeInfo->Equals(name->LocalName(), name->NamespaceID())) {
+ return new txXPathNode(parent, i, root);
+ }
+ }
+
+ NS_ERROR("Couldn't find the attribute in its parent!");
+
+ return nullptr;
+ }
+
+ uint32_t index;
+ nsINode* root = aKeepRootAlive ? aNode : nullptr;
+
+ if (nodeType == nsINode::DOCUMENT_NODE) {
+ index = txXPathNode::eDocument;
+ } else {
+ index = txXPathNode::eContent;
+ if (root) {
+ root = txXPathNode::RootOf(root);
+ }
+ }
+
+ return new txXPathNode(aNode, index, root);
+}
+
+/* static */
+txXPathNode* txXPathNativeNode::createXPathNode(Document* aDocument) {
+ return new txXPathNode(aDocument);
+}
+
+/* static */
+nsINode* txXPathNativeNode::getNode(const txXPathNode& aNode) {
+ if (!aNode.isAttribute()) {
+ return aNode.mNode;
+ }
+
+ const nsAttrName* name =
+ aNode.Content()->AsElement()->GetAttrNameAt(aNode.mIndex);
+
+ nsAutoString namespaceURI;
+ nsNameSpaceManager::GetInstance()->GetNameSpaceURI(name->NamespaceID(),
+ namespaceURI);
+
+ nsCOMPtr<Element> element = do_QueryInterface(aNode.mNode);
+ nsDOMAttributeMap* map = element->Attributes();
+ return map->GetNamedItemNS(namespaceURI,
+ nsDependentAtomString(name->LocalName()));
+}
+
+/* static */
+nsIContent* txXPathNativeNode::getContent(const txXPathNode& aNode) {
+ NS_ASSERTION(aNode.isContent(),
+ "Only call getContent on nsIContent wrappers!");
+ return aNode.Content();
+}
+
+/* static */
+Document* txXPathNativeNode::getDocument(const txXPathNode& aNode) {
+ NS_ASSERTION(aNode.isDocument(),
+ "Only call getDocument on Document wrappers!");
+ return aNode.Document();
+}
diff --git a/dom/xslt/xpath/txNameTest.cpp b/dom/xslt/xpath/txNameTest.cpp
new file mode 100644
index 0000000000..f76113146c
--- /dev/null
+++ b/dom/xslt/xpath/txNameTest.cpp
@@ -0,0 +1,92 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txExpr.h"
+#include "nsAtom.h"
+#include "nsGkAtoms.h"
+#include "txXPathTreeWalker.h"
+#include "txIXPathContext.h"
+
+txNameTest::txNameTest(nsAtom* aPrefix, nsAtom* aLocalName, int32_t aNSID,
+ uint16_t aNodeType)
+ : mPrefix(aPrefix),
+ mLocalName(aLocalName),
+ mNamespace(aNSID),
+ mNodeType(aNodeType) {
+ if (aPrefix == nsGkAtoms::_empty) mPrefix = nullptr;
+ NS_ASSERTION(aLocalName, "txNameTest without a local name?");
+ NS_ASSERTION(aNodeType == txXPathNodeType::DOCUMENT_NODE ||
+ aNodeType == txXPathNodeType::ELEMENT_NODE ||
+ aNodeType == txXPathNodeType::ATTRIBUTE_NODE,
+ "Go fix txNameTest::matches");
+}
+
+nsresult txNameTest::matches(const txXPathNode& aNode,
+ txIMatchContext* aContext, bool& aMatched) {
+ if ((mNodeType == txXPathNodeType::ELEMENT_NODE &&
+ !txXPathNodeUtils::isElement(aNode)) ||
+ (mNodeType == txXPathNodeType::ATTRIBUTE_NODE &&
+ !txXPathNodeUtils::isAttribute(aNode)) ||
+ (mNodeType == txXPathNodeType::DOCUMENT_NODE &&
+ !txXPathNodeUtils::isRoot(aNode))) {
+ aMatched = false;
+ return NS_OK;
+ }
+
+ // Totally wild?
+ if (mLocalName == nsGkAtoms::_asterisk && !mPrefix) {
+ aMatched = true;
+ return NS_OK;
+ }
+
+ // Compare namespaces
+ if (mNamespace != txXPathNodeUtils::getNamespaceID(aNode) &&
+ !(mNamespace == kNameSpaceID_None &&
+ txXPathNodeUtils::isHTMLElementInHTMLDocument(aNode))) {
+ aMatched = false;
+ return NS_OK;
+ }
+
+ // Name wild?
+ if (mLocalName == nsGkAtoms::_asterisk) {
+ aMatched = true;
+ return NS_OK;
+ }
+
+ // Compare local-names
+ aMatched = txXPathNodeUtils::localNameEquals(aNode, mLocalName);
+ return NS_OK;
+}
+
+/*
+ * Returns the default priority of this txNodeTest
+ */
+double txNameTest::getDefaultPriority() {
+ if (mLocalName == nsGkAtoms::_asterisk) {
+ if (!mPrefix) return -0.5;
+ return -0.25;
+ }
+ return 0;
+}
+
+txNodeTest::NodeTestType txNameTest::getType() { return NAME_TEST; }
+
+bool txNameTest::isSensitiveTo(Expr::ContextSensitivity aContext) {
+ return !!(aContext & Expr::NODE_CONTEXT);
+}
+
+#ifdef TX_TO_STRING
+void txNameTest::toString(nsAString& aDest) {
+ if (mPrefix) {
+ nsAutoString prefix;
+ mPrefix->ToString(prefix);
+ aDest.Append(prefix);
+ aDest.Append(char16_t(':'));
+ }
+ nsAutoString localName;
+ mLocalName->ToString(localName);
+ aDest.Append(localName);
+}
+#endif
diff --git a/dom/xslt/xpath/txNamedAttributeStep.cpp b/dom/xslt/xpath/txNamedAttributeStep.cpp
new file mode 100644
index 0000000000..18938e1dd3
--- /dev/null
+++ b/dom/xslt/xpath/txNamedAttributeStep.cpp
@@ -0,0 +1,53 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsAtom.h"
+#include "txIXPathContext.h"
+#include "txNodeSet.h"
+#include "txExpr.h"
+#include "txXPathTreeWalker.h"
+
+txNamedAttributeStep::txNamedAttributeStep(int32_t aNsID, nsAtom* aPrefix,
+ nsAtom* aLocalName)
+ : mNamespace(aNsID), mPrefix(aPrefix), mLocalName(aLocalName) {}
+
+nsresult txNamedAttributeStep::evaluate(txIEvalContext* aContext,
+ txAExprResult** aResult) {
+ *aResult = nullptr;
+
+ RefPtr<txNodeSet> nodes;
+ nsresult rv = aContext->recycler()->getNodeSet(getter_AddRefs(nodes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ txXPathTreeWalker walker(aContext->getContextNode());
+ if (walker.moveToNamedAttribute(mLocalName, mNamespace)) {
+ rv = nodes->append(walker.getCurrentPosition());
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ NS_ADDREF(*aResult = nodes);
+
+ return NS_OK;
+}
+
+TX_IMPL_EXPR_STUBS_0(txNamedAttributeStep, NODESET_RESULT)
+
+bool txNamedAttributeStep::isSensitiveTo(ContextSensitivity aContext) {
+ return !!(aContext & NODE_CONTEXT);
+}
+
+#ifdef TX_TO_STRING
+void txNamedAttributeStep::toString(nsAString& aDest) {
+ aDest.Append(char16_t('@'));
+ if (mPrefix) {
+ nsAutoString prefix;
+ mPrefix->ToString(prefix);
+ aDest.Append(prefix);
+ aDest.Append(char16_t(':'));
+ }
+ nsAutoString localName;
+ mLocalName->ToString(localName);
+ aDest.Append(localName);
+}
+#endif
diff --git a/dom/xslt/xpath/txNodeSet.cpp b/dom/xslt/xpath/txNodeSet.cpp
new file mode 100644
index 0000000000..60eed8952d
--- /dev/null
+++ b/dom/xslt/xpath/txNodeSet.cpp
@@ -0,0 +1,567 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txNodeSet.h"
+#include "txLog.h"
+#include "txXPathTreeWalker.h"
+#include <algorithm>
+
+/**
+ * Implementation of an XPath nodeset
+ */
+
+#ifdef NS_BUILD_REFCNT_LOGGING
+# define LOG_CHUNK_MOVE(_start, _new_start, _count) \
+ { \
+ txXPathNode* start = const_cast<txXPathNode*>(_start); \
+ while (start < _start + _count) { \
+ NS_LogDtor(start, "txXPathNode", sizeof(*start)); \
+ ++start; \
+ } \
+ start = const_cast<txXPathNode*>(_new_start); \
+ while (start < _new_start + _count) { \
+ NS_LogCtor(start, "txXPathNode", sizeof(*start)); \
+ ++start; \
+ } \
+ }
+#else
+# define LOG_CHUNK_MOVE(_start, _new_start, _count)
+#endif
+
+static const int32_t kTxNodeSetMinSize = 4;
+static const int32_t kTxNodeSetGrowFactor = 2;
+
+#define kForward 1
+#define kReversed -1
+
+txNodeSet::txNodeSet(txResultRecycler* aRecycler)
+ : txAExprResult(aRecycler),
+ mStart(nullptr),
+ mEnd(nullptr),
+ mStartBuffer(nullptr),
+ mEndBuffer(nullptr),
+ mDirection(kForward),
+ mMarks(nullptr) {}
+
+txNodeSet::txNodeSet(const txXPathNode& aNode, txResultRecycler* aRecycler)
+ : txAExprResult(aRecycler),
+ mStart(nullptr),
+ mEnd(nullptr),
+ mStartBuffer(nullptr),
+ mEndBuffer(nullptr),
+ mDirection(kForward),
+ mMarks(nullptr) {
+ if (!ensureGrowSize(1)) {
+ return;
+ }
+
+ new (mStart) txXPathNode(aNode);
+ ++mEnd;
+}
+
+txNodeSet::txNodeSet(const txNodeSet& aSource, txResultRecycler* aRecycler)
+ : txAExprResult(aRecycler),
+ mStart(nullptr),
+ mEnd(nullptr),
+ mStartBuffer(nullptr),
+ mEndBuffer(nullptr),
+ mDirection(kForward),
+ mMarks(nullptr) {
+ append(aSource);
+}
+
+txNodeSet::~txNodeSet() {
+ delete[] mMarks;
+
+ if (mStartBuffer) {
+ destroyElements(mStart, mEnd);
+
+ free(mStartBuffer);
+ }
+}
+
+nsresult txNodeSet::add(const txXPathNode& aNode) {
+ NS_ASSERTION(mDirection == kForward,
+ "only append(aNode) is supported on reversed nodesets");
+
+ if (isEmpty()) {
+ return append(aNode);
+ }
+
+ bool dupe;
+ txXPathNode* pos = findPosition(aNode, mStart, mEnd, dupe);
+
+ if (dupe) {
+ return NS_OK;
+ }
+
+ // save pos, ensureGrowSize messes with the pointers
+ int32_t moveSize = mEnd - pos;
+ int32_t offset = pos - mStart;
+ if (!ensureGrowSize(1)) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+ // set pos to where it was
+ pos = mStart + offset;
+
+ if (moveSize > 0) {
+ LOG_CHUNK_MOVE(pos, pos + 1, moveSize);
+ memmove(pos + 1, pos, moveSize * sizeof(txXPathNode));
+ }
+
+ new (pos) txXPathNode(aNode);
+ ++mEnd;
+
+ return NS_OK;
+}
+
+nsresult txNodeSet::add(const txNodeSet& aNodes) {
+ return add(aNodes, copyElements, nullptr);
+}
+
+nsresult txNodeSet::addAndTransfer(txNodeSet* aNodes) {
+ // failure is out-of-memory, transfer didn't happen
+ nsresult rv = add(*aNodes, transferElements, destroyElements);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+#ifdef TX_DONT_RECYCLE_BUFFER
+ if (aNodes->mStartBuffer) {
+ free(aNodes->mStartBuffer);
+ aNodes->mStartBuffer = aNodes->mEndBuffer = nullptr;
+ }
+#endif
+ aNodes->mStart = aNodes->mEnd = aNodes->mStartBuffer;
+
+ return NS_OK;
+}
+
+/**
+ * add(aNodeSet, aTransferOp)
+ *
+ * The code is optimized to make a minimum number of calls to
+ * Node::compareDocumentPosition. The idea is this:
+ * We have the two nodesets (number indicate "document position")
+ *
+ * 1 3 7 <- source 1
+ * 2 3 6 8 9 <- source 2
+ * _ _ _ _ _ _ _ _ <- result
+ *
+ *
+ * When merging these nodesets into the result, the nodes are transfered
+ * in chunks to the end of the buffer so that each chunk does not contain
+ * a node from the other nodeset, in document order.
+ *
+ * We select the last non-transfered node in the first nodeset and find
+ * where in the other nodeset it would be inserted. In this case we would
+ * take the 7 from the first nodeset and find the position between the
+ * 6 and 8 in the second. We then take the nodes after the insert-position
+ * and transfer them to the end of the resulting nodeset. Which in this case
+ * means that we first transfered the 8 and 9 nodes, giving us the following:
+ *
+ * 1 3 7 <- source 1
+ * 2 3 6 <- source 2
+ * _ _ _ _ _ _ 8 9 <- result
+ *
+ * The corresponding procedure is done for the second nodeset, that is
+ * the insertion position of the 6 in the first nodeset is found, which
+ * is between the 3 and the 7. The 7 is memmoved (as it stays within
+ * the same nodeset) to the result buffer.
+ *
+ * As the result buffer is filled from the end, it is safe to share the
+ * buffer between this nodeset and the result.
+ *
+ * This is repeated until both of the nodesets are empty.
+ *
+ * If we find a duplicate node when searching for where insertposition we
+ * check for sequences of duplicate nodes, which can be optimized.
+ *
+ */
+nsresult txNodeSet::add(const txNodeSet& aNodes, transferOp aTransfer,
+ destroyOp aDestroy) {
+ NS_ASSERTION(mDirection == kForward,
+ "only append(aNode) is supported on reversed nodesets");
+
+ if (aNodes.isEmpty()) {
+ return NS_OK;
+ }
+
+ if (!ensureGrowSize(aNodes.size())) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ // This is probably a rather common case, so lets try to shortcut.
+ if (mStart == mEnd ||
+ txXPathNodeUtils::comparePosition(mEnd[-1], *aNodes.mStart) < 0) {
+ aTransfer(mEnd, aNodes.mStart, aNodes.mEnd);
+ mEnd += aNodes.size();
+
+ return NS_OK;
+ }
+
+ // Last element in this nodeset
+ txXPathNode* thisPos = mEnd;
+
+ // Last element of the other nodeset
+ txXPathNode* otherPos = aNodes.mEnd;
+
+ // Pointer to the insertion point in this nodeset
+ txXPathNode* insertPos = mEndBuffer;
+
+ bool dupe;
+ txXPathNode* pos;
+ int32_t count;
+ while (thisPos > mStart || otherPos > aNodes.mStart) {
+ // Find where the last remaining node of this nodeset would
+ // be inserted in the other nodeset.
+ if (thisPos > mStart) {
+ pos = findPosition(thisPos[-1], aNodes.mStart, otherPos, dupe);
+
+ if (dupe) {
+ const txXPathNode* deletePos = thisPos;
+ --thisPos; // this is already added
+ // check dupe sequence
+ while (thisPos > mStart && pos > aNodes.mStart &&
+ thisPos[-1] == pos[-1]) {
+ --thisPos;
+ --pos;
+ }
+
+ if (aDestroy) {
+ aDestroy(thisPos, deletePos);
+ }
+ }
+ } else {
+ pos = aNodes.mStart;
+ }
+
+ // Transfer the otherNodes after the insertion point to the result
+ count = otherPos - pos;
+ if (count > 0) {
+ insertPos -= count;
+ aTransfer(insertPos, pos, otherPos);
+ otherPos -= count;
+ }
+
+ // Find where the last remaining node of the otherNodeset would
+ // be inserted in this nodeset.
+ if (otherPos > aNodes.mStart) {
+ pos = findPosition(otherPos[-1], mStart, thisPos, dupe);
+
+ if (dupe) {
+ const txXPathNode* deletePos = otherPos;
+ --otherPos; // this is already added
+ // check dupe sequence
+ while (otherPos > aNodes.mStart && pos > mStart &&
+ otherPos[-1] == pos[-1]) {
+ --otherPos;
+ --pos;
+ }
+
+ if (aDestroy) {
+ aDestroy(otherPos, deletePos);
+ }
+ }
+ } else {
+ pos = mStart;
+ }
+
+ // Move the nodes from this nodeset after the insertion point
+ // to the result
+ count = thisPos - pos;
+ if (count > 0) {
+ insertPos -= count;
+ LOG_CHUNK_MOVE(pos, insertPos, count);
+ memmove(insertPos, pos, count * sizeof(txXPathNode));
+ thisPos -= count;
+ }
+ }
+ mStart = insertPos;
+ mEnd = mEndBuffer;
+
+ return NS_OK;
+}
+
+/**
+ * Append API
+ * These functions should be used with care.
+ * They are intended to be used when the caller assures that the resulting
+ * nodeset remains in document order.
+ * Abuse will break document order, and cause errors in the result.
+ * These functions are significantly faster than the add API, as no
+ * order info operations will be performed.
+ */
+
+nsresult txNodeSet::append(const txXPathNode& aNode) {
+ if (!ensureGrowSize(1)) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ if (mDirection == kForward) {
+ new (mEnd) txXPathNode(aNode);
+ ++mEnd;
+
+ return NS_OK;
+ }
+
+ new (--mStart) txXPathNode(aNode);
+
+ return NS_OK;
+}
+
+nsresult txNodeSet::append(const txNodeSet& aNodes) {
+ NS_ASSERTION(mDirection == kForward,
+ "only append(aNode) is supported on reversed nodesets");
+
+ if (aNodes.isEmpty()) {
+ return NS_OK;
+ }
+
+ int32_t appended = aNodes.size();
+ if (!ensureGrowSize(appended)) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ copyElements(mEnd, aNodes.mStart, aNodes.mEnd);
+ mEnd += appended;
+
+ return NS_OK;
+}
+
+nsresult txNodeSet::mark(int32_t aIndex) {
+ NS_ASSERTION(aIndex >= 0 && mStart && mEnd - mStart > aIndex,
+ "index out of bounds");
+ if (!mMarks) {
+ int32_t length = size();
+ mMarks = new bool[length];
+ memset(mMarks, 0, length * sizeof(bool));
+ }
+ if (mDirection == kForward) {
+ mMarks[aIndex] = true;
+ } else {
+ mMarks[size() - aIndex - 1] = true;
+ }
+
+ return NS_OK;
+}
+
+nsresult txNodeSet::sweep() {
+ if (!mMarks) {
+ // sweep everything
+ clear();
+ }
+
+ int32_t chunk, pos = 0;
+ int32_t length = size();
+ txXPathNode* insertion = mStartBuffer;
+
+ while (pos < length) {
+ while (pos < length && !mMarks[pos]) {
+ // delete unmarked
+ mStart[pos].~txXPathNode();
+ ++pos;
+ }
+ // find chunk to move
+ chunk = 0;
+ while (pos < length && mMarks[pos]) {
+ ++pos;
+ ++chunk;
+ }
+ // move chunk
+ if (chunk > 0) {
+ LOG_CHUNK_MOVE(mStart + pos - chunk, insertion, chunk);
+ memmove(insertion, mStart + pos - chunk, chunk * sizeof(txXPathNode));
+ insertion += chunk;
+ }
+ }
+ mStart = mStartBuffer;
+ mEnd = insertion;
+ delete[] mMarks;
+ mMarks = nullptr;
+
+ return NS_OK;
+}
+
+void txNodeSet::clear() {
+ destroyElements(mStart, mEnd);
+#ifdef TX_DONT_RECYCLE_BUFFER
+ if (mStartBuffer) {
+ free(mStartBuffer);
+ mStartBuffer = mEndBuffer = nullptr;
+ }
+#endif
+ mStart = mEnd = mStartBuffer;
+ delete[] mMarks;
+ mMarks = nullptr;
+ mDirection = kForward;
+}
+
+int32_t txNodeSet::indexOf(const txXPathNode& aNode, uint32_t aStart) const {
+ NS_ASSERTION(mDirection == kForward,
+ "only append(aNode) is supported on reversed nodesets");
+
+ if (!mStart || mStart == mEnd) {
+ return -1;
+ }
+
+ txXPathNode* pos = mStart + aStart;
+ for (; pos < mEnd; ++pos) {
+ if (*pos == aNode) {
+ return pos - mStart;
+ }
+ }
+
+ return -1;
+}
+
+const txXPathNode& txNodeSet::get(int32_t aIndex) const {
+ if (mDirection == kForward) {
+ return mStart[aIndex];
+ }
+
+ return mEnd[-aIndex - 1];
+}
+
+short txNodeSet::getResultType() { return txAExprResult::NODESET; }
+
+bool txNodeSet::booleanValue() { return !isEmpty(); }
+double txNodeSet::numberValue() {
+ nsAutoString str;
+ stringValue(str);
+
+ return txDouble::toDouble(str);
+}
+
+void txNodeSet::stringValue(nsString& aStr) {
+ NS_ASSERTION(mDirection == kForward,
+ "only append(aNode) is supported on reversed nodesets");
+ if (isEmpty()) {
+ return;
+ }
+ txXPathNodeUtils::appendNodeValue(get(0), aStr);
+}
+
+const nsString* txNodeSet::stringValuePointer() { return nullptr; }
+
+bool txNodeSet::ensureGrowSize(int32_t aSize) {
+ // check if there is enough place in the buffer as is
+ if (mDirection == kForward && aSize <= mEndBuffer - mEnd) {
+ return true;
+ }
+
+ if (mDirection == kReversed && aSize <= mStart - mStartBuffer) {
+ return true;
+ }
+
+ // check if we just have to align mStart to have enough space
+ int32_t oldSize = mEnd - mStart;
+ int32_t oldLength = mEndBuffer - mStartBuffer;
+ int32_t ensureSize = oldSize + aSize;
+ if (ensureSize <= oldLength) {
+ // just move the buffer
+ txXPathNode* dest = mStartBuffer;
+ if (mDirection == kReversed) {
+ dest = mEndBuffer - oldSize;
+ }
+ LOG_CHUNK_MOVE(mStart, dest, oldSize);
+ memmove(dest, mStart, oldSize * sizeof(txXPathNode));
+ mStart = dest;
+ mEnd = dest + oldSize;
+
+ return true;
+ }
+
+ // This isn't 100% safe. But until someone manages to make a 1gig nodeset
+ // it should be ok.
+ int32_t newLength = std::max(oldLength, kTxNodeSetMinSize);
+
+ while (newLength < ensureSize) {
+ newLength *= kTxNodeSetGrowFactor;
+ }
+
+ txXPathNode* newArr =
+ static_cast<txXPathNode*>(moz_xmalloc(newLength * sizeof(txXPathNode)));
+
+ txXPathNode* dest = newArr;
+ if (mDirection == kReversed) {
+ dest += newLength - oldSize;
+ }
+
+ if (oldSize > 0) {
+ LOG_CHUNK_MOVE(mStart, dest, oldSize);
+ memcpy(dest, mStart, oldSize * sizeof(txXPathNode));
+ }
+
+ if (mStartBuffer) {
+#ifdef DEBUG
+ memset(mStartBuffer, 0, (mEndBuffer - mStartBuffer) * sizeof(txXPathNode));
+#endif
+ free(mStartBuffer);
+ }
+
+ mStartBuffer = newArr;
+ mEndBuffer = mStartBuffer + newLength;
+ mStart = dest;
+ mEnd = dest + oldSize;
+
+ return true;
+}
+
+txXPathNode* txNodeSet::findPosition(const txXPathNode& aNode,
+ txXPathNode* aFirst, txXPathNode* aLast,
+ bool& aDupe) const {
+ aDupe = false;
+ if (aLast - aFirst <= 2) {
+ // If we search 2 nodes or less there is no point in further divides
+ txXPathNode* pos = aFirst;
+ for (; pos < aLast; ++pos) {
+ int cmp = txXPathNodeUtils::comparePosition(aNode, *pos);
+ if (cmp < 0) {
+ return pos;
+ }
+
+ if (cmp == 0) {
+ aDupe = true;
+
+ return pos;
+ }
+ }
+ return pos;
+ }
+
+ // (cannot add two pointers)
+ txXPathNode* midpos = aFirst + (aLast - aFirst) / 2;
+ int cmp = txXPathNodeUtils::comparePosition(aNode, *midpos);
+ if (cmp == 0) {
+ aDupe = true;
+
+ return midpos;
+ }
+
+ if (cmp > 0) {
+ return findPosition(aNode, midpos + 1, aLast, aDupe);
+ }
+
+ // midpos excluded as end of range
+
+ return findPosition(aNode, aFirst, midpos, aDupe);
+}
+
+/* static */
+void txNodeSet::copyElements(txXPathNode* aDest, const txXPathNode* aStart,
+ const txXPathNode* aEnd) {
+ const txXPathNode* pos = aStart;
+ while (pos < aEnd) {
+ new (aDest) txXPathNode(*pos);
+ ++aDest;
+ ++pos;
+ }
+}
+
+/* static */
+void txNodeSet::transferElements(txXPathNode* aDest, const txXPathNode* aStart,
+ const txXPathNode* aEnd) {
+ LOG_CHUNK_MOVE(aStart, aDest, (aEnd - aStart));
+ memcpy(aDest, aStart, (aEnd - aStart) * sizeof(txXPathNode));
+}
diff --git a/dom/xslt/xpath/txNodeSet.h b/dom/xslt/xpath/txNodeSet.h
new file mode 100644
index 0000000000..8c5e805d6b
--- /dev/null
+++ b/dom/xslt/xpath/txNodeSet.h
@@ -0,0 +1,199 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Implementation of an XPath NodeSet
+ */
+
+#ifndef txNodeSet_h__
+#define txNodeSet_h__
+
+#include "txExprResult.h"
+#include "nsError.h"
+#include "txXPathNode.h"
+
+class txNodeSet : public txAExprResult {
+ public:
+ /**
+ * Creates a new empty NodeSet
+ */
+ explicit txNodeSet(txResultRecycler* aRecycler);
+
+ /**
+ * Creates a new NodeSet with one node.
+ */
+ txNodeSet(const txXPathNode& aNode, txResultRecycler* aRecycler);
+
+ /**
+ * Creates a new txNodeSet, copying the node references from the source
+ * NodeSet.
+ */
+ txNodeSet(const txNodeSet& aSource, txResultRecycler* aRecycler);
+
+ /**
+ * Destructor for txNodeSet, deletes the nodes.
+ */
+ virtual ~txNodeSet();
+
+ /**
+ * Adds the specified txXPathNode to this NodeSet if it is not already
+ * in this NodeSet. The node is inserted according to document order.
+ *
+ * @param aNode the txXPathNode to add to the NodeSet
+ * @return errorcode.
+ */
+ nsresult add(const txXPathNode& aNode);
+
+ /**
+ * Adds the nodes in specified NodeSet to this NodeSet. The resulting
+ * NodeSet is sorted in document order and does not contain any duplicate
+ * nodes.
+ *
+ * @param aNodes the NodeSet to add, must be in document order.
+ * @return errorcode.
+ */
+ nsresult add(const txNodeSet& aNodes);
+ nsresult addAndTransfer(txNodeSet* aNodes);
+
+ /**
+ * Append API
+ * These functions should be used with care.
+ * They are intended to be used when the caller assures that the resulting
+ * NodeSet remains in document order.
+ * Abuse will break document order, and cause errors in the result.
+ * These functions are significantly faster than the add API, as no
+ * order info operations will be performed.
+ */
+
+ /**
+ * Appends the specified Node to the end of this NodeSet
+ * @param aNode the Node to append to the NodeSet
+ * @return errorcode.
+ */
+ nsresult append(const txXPathNode& aNode);
+
+ /**
+ * Appends the nodes in the specified NodeSet to the end of this NodeSet
+ * @param aNodes the NodeSet to append to the NodeSet
+ * @return errorcode.
+ */
+ nsresult append(const txNodeSet& aNodes);
+
+ /**
+ * API to implement reverse axes in LocationStep.
+ *
+ * Before adding nodes to the nodeset for a reversed axis, call
+ * setReverse(). This will make the append(aNode) and get() methods treat
+ * the nodeset as required. Do only call append(aNode), get(), mark()
+ * and sweep() while the nodeset is reversed.
+ * Afterwards, call unsetReverse(). The nodes are stored in document
+ * order internally.
+ */
+ void setReverse() { mDirection = -1; }
+ void unsetReverse() { mDirection = 1; }
+
+ /**
+ * API to implement predicates in PredicateExpr
+ *
+ * mark(aIndex) marks the specified member of the nodeset.
+ * sweep() clears all members of the nodeset that haven't been
+ * marked before and clear the mMarks array.
+ */
+ nsresult mark(int32_t aIndex);
+ nsresult sweep();
+
+ /**
+ * Removes all nodes from this nodeset
+ */
+ void clear();
+
+ /**
+ * Returns the index of the specified Node,
+ * or -1 if the Node is not contained in the NodeSet
+ * @param aNode the Node to get the index for
+ * @param aStart index to start searching at
+ * @return index of specified node or -1 if the node does not exist
+ */
+ int32_t indexOf(const txXPathNode& aNode, uint32_t aStart = 0) const;
+
+ /**
+ * Returns true if the specified Node is contained in the set.
+ * @param aNode the Node to search for
+ * @return true if specified Node is contained in the NodeSet
+ */
+ bool contains(const txXPathNode& aNode) const { return indexOf(aNode) >= 0; }
+
+ /**
+ * Returns the Node at the specified node in this NodeSet.
+ * @param aIndex the node of the Node to return
+ * @return Node at specified node
+ */
+ const txXPathNode& get(int32_t aIndex) const;
+
+ /**
+ * Returns true if there are no Nodes in the NodeSet.
+ * @return true if there are no Nodes in the NodeSet.
+ */
+ bool isEmpty() const { return mStart ? mStart == mEnd : true; }
+
+ /**
+ * Returns the number of elements in the NodeSet
+ * @return the number of elements in the NodeSet
+ */
+ int32_t size() const { return mStart ? mEnd - mStart : 0; }
+
+ TX_DECL_EXPRRESULT
+
+ private:
+ /**
+ * Ensure that this nodeset can take another aSize nodes.
+ *
+ * Changes mStart and mEnd as well as mBufferStart and mBufferEnd.
+ */
+ bool ensureGrowSize(int32_t aSize);
+
+ /**
+ * Finds position in the buffer where a node should be inserted
+ * to keep the nodeset in document order. Searches the positions
+ * aFirst-aLast, including aFirst, but not aLast.
+ * @param aNode Node to find insert position for.
+ * @param aFirst First item of the search range, included.
+ * @param aLast Last item of the search range, excluded.
+ * @param aDupe out-param. Will be set to true if the node already
+ * exists in the NodeSet, false if it should be
+ * inserted.
+ * @return pointer where to insert the node. The node should be inserted
+ * before the given node. This value is always set, even if aNode
+ * already exists in the NodeSet
+ */
+ txXPathNode* findPosition(const txXPathNode& aNode, txXPathNode* aFirst,
+ txXPathNode* aLast, bool& aDupe) const;
+
+ static void copyElements(txXPathNode* aDest, const txXPathNode* aStart,
+ const txXPathNode* aEnd);
+ static void transferElements(txXPathNode* aDest, const txXPathNode* aStart,
+ const txXPathNode* aEnd);
+ static void destroyElements(const txXPathNode* aStart,
+ const txXPathNode* aEnd) {
+ while (aStart < aEnd) {
+ aStart->~txXPathNode();
+ ++aStart;
+ }
+ }
+
+ using transferOp = void (*)(txXPathNode* aDest, const txXPathNode* aStart,
+ const txXPathNode* aEnd);
+ using destroyOp = void (*)(const txXPathNode* aStart,
+ const txXPathNode* aEnd);
+ nsresult add(const txNodeSet& aNodes, transferOp aTransfer,
+ destroyOp aDestroy);
+
+ txXPathNode *mStart, *mEnd, *mStartBuffer, *mEndBuffer;
+ int32_t mDirection;
+ // used for mark() and sweep() in predicates
+ bool* mMarks;
+};
+
+#endif
diff --git a/dom/xslt/xpath/txNodeSetContext.cpp b/dom/xslt/xpath/txNodeSetContext.cpp
new file mode 100644
index 0000000000..7565e12545
--- /dev/null
+++ b/dom/xslt/xpath/txNodeSetContext.cpp
@@ -0,0 +1,51 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txNodeSetContext.h"
+#include "txNodeSet.h"
+
+const txXPathNode& txNodeSetContext::getContextNode() {
+ return mContextSet->get(mPosition - 1);
+}
+
+uint32_t txNodeSetContext::size() { return (uint32_t)mContextSet->size(); }
+
+uint32_t txNodeSetContext::position() {
+ NS_ASSERTION(mPosition, "Should have called next() at least once");
+ return mPosition;
+}
+
+nsresult txNodeSetContext::getVariable(int32_t aNamespace, nsAtom* aLName,
+ txAExprResult*& aResult) {
+ NS_ASSERTION(mInner, "mInner is null!!!");
+ return mInner->getVariable(aNamespace, aLName, aResult);
+}
+
+nsresult txNodeSetContext::isStripSpaceAllowed(const txXPathNode& aNode,
+ bool& aAllowed) {
+ NS_ASSERTION(mInner, "mInner is null!!!");
+ return mInner->isStripSpaceAllowed(aNode, aAllowed);
+}
+
+void* txNodeSetContext::getPrivateContext() {
+ NS_ASSERTION(mInner, "mInner is null!!!");
+ return mInner->getPrivateContext();
+}
+
+txResultRecycler* txNodeSetContext::recycler() {
+ NS_ASSERTION(mInner, "mInner is null!!!");
+ return mInner->recycler();
+}
+
+void txNodeSetContext::receiveError(const nsAString& aMsg, nsresult aRes) {
+ NS_ASSERTION(mInner, "mInner is null!!!");
+#ifdef DEBUG
+ nsAutoString error(u"forwarded error: "_ns);
+ error.Append(aMsg);
+ mInner->receiveError(error, aRes);
+#else
+ mInner->receiveError(aMsg, aRes);
+#endif
+}
diff --git a/dom/xslt/xpath/txNodeSetContext.h b/dom/xslt/xpath/txNodeSetContext.h
new file mode 100644
index 0000000000..86cb14ab95
--- /dev/null
+++ b/dom/xslt/xpath/txNodeSetContext.h
@@ -0,0 +1,36 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef __TX_XPATH_SET_CONTEXT
+#define __TX_XPATH_SET_CONTEXT
+
+#include "txIXPathContext.h"
+#include "txNodeSet.h"
+
+class txNodeSetContext : public txIEvalContext {
+ public:
+ txNodeSetContext(txNodeSet* aContextNodeSet, txIMatchContext* aContext)
+ : mContextSet(aContextNodeSet), mPosition(0), mInner(aContext) {}
+
+ // Iteration over the given NodeSet
+ bool hasNext() { return mPosition < size(); }
+ void next() {
+ NS_ASSERTION(mPosition < size(), "Out of bounds.");
+ mPosition++;
+ }
+ void setPosition(uint32_t aPosition) {
+ NS_ASSERTION(aPosition > 0 && aPosition <= size(), "Out of bounds.");
+ mPosition = aPosition;
+ }
+
+ TX_DECL_EVAL_CONTEXT;
+
+ protected:
+ RefPtr<txNodeSet> mContextSet;
+ uint32_t mPosition;
+ txIMatchContext* mInner;
+};
+
+#endif // __TX_XPATH_SET_CONTEXT
diff --git a/dom/xslt/xpath/txNodeTypeTest.cpp b/dom/xslt/xpath/txNodeTypeTest.cpp
new file mode 100644
index 0000000000..17d0c60483
--- /dev/null
+++ b/dom/xslt/xpath/txNodeTypeTest.cpp
@@ -0,0 +1,91 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txExpr.h"
+#include "nsAtom.h"
+#include "txIXPathContext.h"
+#include "txXPathTreeWalker.h"
+
+nsresult txNodeTypeTest::matches(const txXPathNode& aNode,
+ txIMatchContext* aContext, bool& aMatched) {
+ switch (mNodeType) {
+ case COMMENT_TYPE: {
+ aMatched = txXPathNodeUtils::isComment(aNode);
+ return NS_OK;
+ }
+ case TEXT_TYPE: {
+ aMatched = txXPathNodeUtils::isText(aNode);
+ if (aMatched) {
+ bool allowed;
+ nsresult rv = aContext->isStripSpaceAllowed(aNode, allowed);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aMatched = !allowed;
+ }
+ return NS_OK;
+ }
+ case PI_TYPE: {
+ aMatched =
+ txXPathNodeUtils::isProcessingInstruction(aNode) &&
+ (!mNodeName || txXPathNodeUtils::localNameEquals(aNode, mNodeName));
+ return NS_OK;
+ }
+ case NODE_TYPE: {
+ if (txXPathNodeUtils::isText(aNode)) {
+ bool allowed;
+ nsresult rv = aContext->isStripSpaceAllowed(aNode, allowed);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aMatched = !allowed;
+ } else {
+ aMatched = true;
+ }
+ return NS_OK;
+ }
+ }
+
+ MOZ_ASSERT_UNREACHABLE("Didn't deal with all values of the NodeType enum!");
+
+ aMatched = false;
+ return NS_OK;
+}
+
+txNodeTest::NodeTestType txNodeTypeTest::getType() { return NODETYPE_TEST; }
+
+/*
+ * Returns the default priority of this txNodeTest
+ */
+double txNodeTypeTest::getDefaultPriority() { return mNodeName ? 0 : -0.5; }
+
+bool txNodeTypeTest::isSensitiveTo(Expr::ContextSensitivity aContext) {
+ return !!(aContext & Expr::NODE_CONTEXT);
+}
+
+#ifdef TX_TO_STRING
+void txNodeTypeTest::toString(nsAString& aDest) {
+ switch (mNodeType) {
+ case COMMENT_TYPE:
+ aDest.AppendLiteral("comment()");
+ break;
+ case TEXT_TYPE:
+ aDest.AppendLiteral("text()");
+ break;
+ case PI_TYPE:
+ aDest.AppendLiteral("processing-instruction(");
+ if (mNodeName) {
+ nsAutoString str;
+ mNodeName->ToString(str);
+ aDest.Append(char16_t('\''));
+ aDest.Append(str);
+ aDest.Append(char16_t('\''));
+ }
+ aDest.Append(char16_t(')'));
+ break;
+ case NODE_TYPE:
+ aDest.AppendLiteral("node()");
+ break;
+ }
+}
+#endif
diff --git a/dom/xslt/xpath/txNumberExpr.cpp b/dom/xslt/xpath/txNumberExpr.cpp
new file mode 100644
index 0000000000..c3424a91f1
--- /dev/null
+++ b/dom/xslt/xpath/txNumberExpr.cpp
@@ -0,0 +1,108 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/FloatingPoint.h"
+
+#include "txExpr.h"
+#include <math.h>
+#include "txIXPathContext.h"
+
+nsresult txNumberExpr::evaluate(txIEvalContext* aContext,
+ txAExprResult** aResult) {
+ *aResult = nullptr;
+
+ RefPtr<txAExprResult> exprRes;
+ nsresult rv = mRightExpr->evaluate(aContext, getter_AddRefs(exprRes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ double rightDbl = exprRes->numberValue();
+
+ rv = mLeftExpr->evaluate(aContext, getter_AddRefs(exprRes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ double leftDbl = exprRes->numberValue();
+ double result = 0;
+
+ switch (mOp) {
+ case ADD:
+ result = leftDbl + rightDbl;
+ break;
+
+ case SUBTRACT:
+ result = leftDbl - rightDbl;
+ break;
+
+ case DIVIDE:
+ if (rightDbl == 0) {
+#if defined(XP_WIN)
+ /* XXX MSVC miscompiles such that (NaN == 0) */
+ if (std::isnan(rightDbl))
+ result = mozilla::UnspecifiedNaN<double>();
+ else
+#endif
+ if (leftDbl == 0 || std::isnan(leftDbl))
+ result = mozilla::UnspecifiedNaN<double>();
+ else if (mozilla::IsNegative(leftDbl) != mozilla::IsNegative(rightDbl))
+ result = mozilla::NegativeInfinity<double>();
+ else
+ result = mozilla::PositiveInfinity<double>();
+ } else
+ result = leftDbl / rightDbl;
+ break;
+
+ case MODULUS:
+ if (rightDbl == 0) {
+ result = mozilla::UnspecifiedNaN<double>();
+ } else {
+#if defined(XP_WIN)
+ /* Workaround MS fmod bug where 42 % (1/0) => NaN, not 42. */
+ if (!std::isinf(leftDbl) && std::isinf(rightDbl))
+ result = leftDbl;
+ else
+#endif
+ result = fmod(leftDbl, rightDbl);
+ }
+ break;
+
+ case MULTIPLY:
+ result = leftDbl * rightDbl;
+ break;
+ }
+
+ return aContext->recycler()->getNumberResult(result, aResult);
+} //-- evaluate
+
+TX_IMPL_EXPR_STUBS_2(txNumberExpr, NUMBER_RESULT, mLeftExpr, mRightExpr)
+
+bool txNumberExpr::isSensitiveTo(ContextSensitivity aContext) {
+ return mLeftExpr->isSensitiveTo(aContext) ||
+ mRightExpr->isSensitiveTo(aContext);
+}
+
+#ifdef TX_TO_STRING
+void txNumberExpr::toString(nsAString& str) {
+ mLeftExpr->toString(str);
+
+ switch (mOp) {
+ case ADD:
+ str.AppendLiteral(" + ");
+ break;
+ case SUBTRACT:
+ str.AppendLiteral(" - ");
+ break;
+ case DIVIDE:
+ str.AppendLiteral(" div ");
+ break;
+ case MODULUS:
+ str.AppendLiteral(" mod ");
+ break;
+ case MULTIPLY:
+ str.AppendLiteral(" * ");
+ break;
+ }
+
+ mRightExpr->toString(str);
+}
+#endif
diff --git a/dom/xslt/xpath/txNumberResult.cpp b/dom/xslt/xpath/txNumberResult.cpp
new file mode 100644
index 0000000000..370a7523d8
--- /dev/null
+++ b/dom/xslt/xpath/txNumberResult.cpp
@@ -0,0 +1,48 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * NumberResult
+ * Represents the a number as the result of evaluating an Expr
+ **/
+
+#include "mozilla/FloatingPoint.h"
+
+#include "txExprResult.h"
+
+/**
+ * Default Constructor
+ **/
+
+/**
+ * Creates a new NumberResult with the value of the given double parameter
+ * @param dbl the double to use for initialization of this NumberResult's value
+ **/
+NumberResult::NumberResult(double aValue, txResultRecycler* aRecycler)
+ : txAExprResult(aRecycler), value(aValue) {} //-- NumberResult
+
+/*
+ * Virtual Methods from ExprResult
+ */
+
+short NumberResult::getResultType() {
+ return txAExprResult::NUMBER;
+} //-- getResultType
+
+void NumberResult::stringValue(nsString& aResult) {
+ txDouble::toString(value, aResult);
+}
+
+const nsString* NumberResult::stringValuePointer() { return nullptr; }
+
+bool NumberResult::booleanValue() {
+ // OG+
+ // As per the XPath spec, the boolean value of a number is true if and only if
+ // it is neither positive 0 nor negative 0 nor NaN
+ return (bool)(value != 0.0 && !std::isnan(value));
+ // OG-
+} //-- booleanValue
+
+double NumberResult::numberValue() { return this->value; } //-- numberValue
diff --git a/dom/xslt/xpath/txPathExpr.cpp b/dom/xslt/xpath/txPathExpr.cpp
new file mode 100644
index 0000000000..79be4caa08
--- /dev/null
+++ b/dom/xslt/xpath/txPathExpr.cpp
@@ -0,0 +1,229 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txExpr.h"
+#include "txNodeSet.h"
+#include "txNodeSetContext.h"
+#include "txSingleNodeContext.h"
+#include "txXMLUtils.h"
+#include "txXPathTreeWalker.h"
+
+using mozilla::Unused;
+using mozilla::WrapUnique;
+
+//------------/
+//- PathExpr -/
+//------------/
+
+/**
+ * Adds the Expr to this PathExpr
+ * @param expr the Expr to add to this PathExpr
+ **/
+void PathExpr::addExpr(Expr* aExpr, PathOperator aPathOp) {
+ NS_ASSERTION(!mItems.IsEmpty() || aPathOp == RELATIVE_OP,
+ "First step has to be relative in PathExpr");
+ PathExprItem* pxi = mItems.AppendElement();
+ pxi->expr = WrapUnique(aExpr);
+ pxi->pathOp = aPathOp;
+}
+
+//-----------------------------/
+//- Virtual methods from Expr -/
+//-----------------------------/
+
+/**
+ * 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 PathExpr::evaluate(txIEvalContext* aContext, txAExprResult** aResult) {
+ *aResult = nullptr;
+
+ // We need to evaluate the first step with the current context since it
+ // can depend on the context size and position. For example:
+ // key('books', concat('book', position()))
+ RefPtr<txAExprResult> res;
+ nsresult rv = mItems[0].expr->evaluate(aContext, getter_AddRefs(res));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ NS_ENSURE_TRUE(res->getResultType() == txAExprResult::NODESET,
+ NS_ERROR_XSLT_NODESET_EXPECTED);
+
+ RefPtr<txNodeSet> nodes =
+ static_cast<txNodeSet*>(static_cast<txAExprResult*>(res));
+ if (nodes->isEmpty()) {
+ res.forget(aResult);
+
+ return NS_OK;
+ }
+ res = nullptr; // To allow recycling
+
+ // Evaluate remaining steps
+ uint32_t i, len = mItems.Length();
+ for (i = 1; i < len; ++i) {
+ PathExprItem& pxi = mItems[i];
+ RefPtr<txNodeSet> tmpNodes;
+ txNodeSetContext eContext(nodes, aContext);
+ while (eContext.hasNext()) {
+ eContext.next();
+
+ RefPtr<txNodeSet> resNodes;
+ if (pxi.pathOp == DESCENDANT_OP) {
+ rv = aContext->recycler()->getNodeSet(getter_AddRefs(resNodes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = evalDescendants(pxi.expr.get(), eContext.getContextNode(),
+ &eContext, resNodes);
+ NS_ENSURE_SUCCESS(rv, rv);
+ } else {
+ RefPtr<txAExprResult> res;
+ rv = pxi.expr->evaluate(&eContext, getter_AddRefs(res));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (res->getResultType() != txAExprResult::NODESET) {
+ // XXX ErrorReport: report nonnodeset error
+ return NS_ERROR_XSLT_NODESET_EXPECTED;
+ }
+ resNodes = static_cast<txNodeSet*>(static_cast<txAExprResult*>(res));
+ }
+
+ if (tmpNodes) {
+ if (!resNodes->isEmpty()) {
+ RefPtr<txNodeSet> oldSet;
+ oldSet.swap(tmpNodes);
+ rv = aContext->recycler()->getNonSharedNodeSet(
+ oldSet, getter_AddRefs(tmpNodes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ oldSet.swap(resNodes);
+ rv = aContext->recycler()->getNonSharedNodeSet(
+ oldSet, getter_AddRefs(resNodes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ tmpNodes->addAndTransfer(resNodes);
+ }
+ } else {
+ tmpNodes = resNodes;
+ }
+ }
+ nodes = tmpNodes;
+ if (nodes->isEmpty()) {
+ break;
+ }
+ }
+
+ *aResult = nodes;
+ NS_ADDREF(*aResult);
+
+ return NS_OK;
+} //-- evaluate
+
+/**
+ * Selects from the descendants of the context node
+ * all nodes that match the Expr
+ **/
+nsresult PathExpr::evalDescendants(Expr* aStep, const txXPathNode& aNode,
+ txIMatchContext* aContext,
+ txNodeSet* resNodes) {
+ txSingleNodeContext eContext(aNode, aContext);
+ RefPtr<txAExprResult> res;
+ nsresult rv = aStep->evaluate(&eContext, getter_AddRefs(res));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (res->getResultType() != txAExprResult::NODESET) {
+ // XXX ErrorReport: report nonnodeset error
+ return NS_ERROR_XSLT_NODESET_EXPECTED;
+ }
+
+ txNodeSet* oldSet = static_cast<txNodeSet*>(static_cast<txAExprResult*>(res));
+ RefPtr<txNodeSet> newSet;
+ rv =
+ aContext->recycler()->getNonSharedNodeSet(oldSet, getter_AddRefs(newSet));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ resNodes->addAndTransfer(newSet);
+
+ bool filterWS;
+ rv = aContext->isStripSpaceAllowed(aNode, filterWS);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ txXPathTreeWalker walker(aNode);
+ if (!walker.moveToFirstChild()) {
+ return NS_OK;
+ }
+
+ do {
+ const txXPathNode& node = walker.getCurrentPosition();
+ if (!(filterWS && txXPathNodeUtils::isText(node) &&
+ txXPathNodeUtils::isWhitespace(node))) {
+ rv = evalDescendants(aStep, node, aContext, resNodes);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ } while (walker.moveToNextSibling());
+
+ return NS_OK;
+} //-- evalDescendants
+
+Expr::ExprType PathExpr::getType() { return PATH_EXPR; }
+
+TX_IMPL_EXPR_STUBS_BASE(PathExpr, NODESET_RESULT)
+
+Expr* PathExpr::getSubExprAt(uint32_t aPos) {
+ return aPos < mItems.Length() ? mItems[aPos].expr.get() : nullptr;
+}
+void PathExpr::setSubExprAt(uint32_t aPos, Expr* aExpr) {
+ NS_ASSERTION(aPos < mItems.Length(), "setting bad subexpression index");
+ Unused << mItems[aPos].expr.release();
+ mItems[aPos].expr = WrapUnique(aExpr);
+}
+
+bool PathExpr::isSensitiveTo(ContextSensitivity aContext) {
+ if (mItems[0].expr->isSensitiveTo(aContext)) {
+ return true;
+ }
+
+ // We're creating a new node/nodeset so we can ignore those bits.
+ Expr::ContextSensitivity context =
+ aContext & ~(Expr::NODE_CONTEXT | Expr::NODESET_CONTEXT);
+ if (context == NO_CONTEXT) {
+ return false;
+ }
+
+ uint32_t i, len = mItems.Length();
+ for (i = 0; i < len; ++i) {
+ NS_ASSERTION(!mItems[i].expr->isSensitiveTo(Expr::NODESET_CONTEXT),
+ "Step cannot depend on nodeset-context");
+ if (mItems[i].expr->isSensitiveTo(context)) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+#ifdef TX_TO_STRING
+void PathExpr::toString(nsAString& dest) {
+ if (!mItems.IsEmpty()) {
+ NS_ASSERTION(mItems[0].pathOp == RELATIVE_OP,
+ "First step should be relative");
+ mItems[0].expr->toString(dest);
+ }
+
+ uint32_t i, len = mItems.Length();
+ for (i = 1; i < len; ++i) {
+ switch (mItems[i].pathOp) {
+ case DESCENDANT_OP:
+ dest.AppendLiteral("//");
+ break;
+ case RELATIVE_OP:
+ dest.Append(char16_t('/'));
+ break;
+ }
+ mItems[i].expr->toString(dest);
+ }
+}
+#endif
diff --git a/dom/xslt/xpath/txPredicateList.cpp b/dom/xslt/xpath/txPredicateList.cpp
new file mode 100644
index 0000000000..ad2804caef
--- /dev/null
+++ b/dom/xslt/xpath/txPredicateList.cpp
@@ -0,0 +1,78 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txExpr.h"
+#include "txNodeSet.h"
+#include "txNodeSetContext.h"
+
+/*
+ * Represents an ordered list of Predicates,
+ * for use with Step and Filter Expressions
+ */
+
+nsresult PredicateList::evaluatePredicates(txNodeSet* nodes,
+ txIMatchContext* aContext) {
+ NS_ASSERTION(nodes, "called evaluatePredicates with nullptr NodeSet");
+ nsresult rv = NS_OK;
+
+ uint32_t i, len = mPredicates.Length();
+ for (i = 0; i < len && !nodes->isEmpty(); ++i) {
+ txNodeSetContext predContext(nodes, aContext);
+ /*
+ * add nodes to newNodes that match the expression
+ * or, if the result is a number, add the node with the right
+ * position
+ */
+ int32_t index = 0;
+ while (predContext.hasNext()) {
+ predContext.next();
+ RefPtr<txAExprResult> exprResult;
+ rv = mPredicates[i]->evaluate(&predContext, getter_AddRefs(exprResult));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // handle default, [position() == numberValue()]
+ if (exprResult->getResultType() == txAExprResult::NUMBER) {
+ if ((double)predContext.position() == exprResult->numberValue()) {
+ nodes->mark(index);
+ }
+ } else if (exprResult->booleanValue()) {
+ nodes->mark(index);
+ }
+ ++index;
+ }
+ // sweep the non-marked nodes
+ nodes->sweep();
+ }
+
+ return NS_OK;
+}
+
+bool PredicateList::isSensitiveTo(Expr::ContextSensitivity aContext) {
+ // We're creating a new node/nodeset so we can ignore those bits.
+ Expr::ContextSensitivity context =
+ aContext & ~(Expr::NODE_CONTEXT | Expr::NODESET_CONTEXT);
+ if (context == Expr::NO_CONTEXT) {
+ return false;
+ }
+
+ uint32_t i, len = mPredicates.Length();
+ for (i = 0; i < len; ++i) {
+ if (mPredicates[i]->isSensitiveTo(context)) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+#ifdef TX_TO_STRING
+void PredicateList::toString(nsAString& dest) {
+ for (uint32_t i = 0; i < mPredicates.Length(); ++i) {
+ dest.Append(char16_t('['));
+ mPredicates[i]->toString(dest);
+ dest.Append(char16_t(']'));
+ }
+}
+#endif
diff --git a/dom/xslt/xpath/txPredicatedNodeTest.cpp b/dom/xslt/xpath/txPredicatedNodeTest.cpp
new file mode 100644
index 0000000000..6c3fd33cf5
--- /dev/null
+++ b/dom/xslt/xpath/txPredicatedNodeTest.cpp
@@ -0,0 +1,50 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txExpr.h"
+#include "txExprResult.h"
+#include "txSingleNodeContext.h"
+
+txPredicatedNodeTest::txPredicatedNodeTest(txNodeTest* aNodeTest,
+ Expr* aPredicate)
+ : mNodeTest(aNodeTest), mPredicate(aPredicate) {
+ NS_ASSERTION(!mPredicate->isSensitiveTo(Expr::NODESET_CONTEXT),
+ "predicate must not be context-nodeset-sensitive");
+}
+
+nsresult txPredicatedNodeTest::matches(const txXPathNode& aNode,
+ txIMatchContext* aContext,
+ bool& aMatched) {
+ nsresult rv = mNodeTest->matches(aNode, aContext, aMatched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (!aMatched) {
+ return NS_OK;
+ }
+
+ txSingleNodeContext context(aNode, aContext);
+ RefPtr<txAExprResult> res;
+ rv = mPredicate->evaluate(&context, getter_AddRefs(res));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aMatched = res->booleanValue();
+ return NS_OK;
+}
+
+double txPredicatedNodeTest::getDefaultPriority() { return 0.5; }
+
+bool txPredicatedNodeTest::isSensitiveTo(Expr::ContextSensitivity aContext) {
+ return mNodeTest->isSensitiveTo(aContext) ||
+ mPredicate->isSensitiveTo(aContext);
+}
+
+#ifdef TX_TO_STRING
+void txPredicatedNodeTest::toString(nsAString& aDest) {
+ mNodeTest->toString(aDest);
+ aDest.Append(char16_t('['));
+ mPredicate->toString(aDest);
+ aDest.Append(char16_t(']'));
+}
+#endif
diff --git a/dom/xslt/xpath/txRelationalExpr.cpp b/dom/xslt/xpath/txRelationalExpr.cpp
new file mode 100644
index 0000000000..df6da87ca8
--- /dev/null
+++ b/dom/xslt/xpath/txRelationalExpr.cpp
@@ -0,0 +1,184 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txExpr.h"
+#include "txNodeSet.h"
+#include "txIXPathContext.h"
+#include "txXPathTreeWalker.h"
+
+/**
+ * Compares the two ExprResults based on XPath 1.0 Recommendation (section 3.4)
+ */
+bool RelationalExpr::compareResults(txIEvalContext* aContext,
+ txAExprResult* aLeft,
+ txAExprResult* aRight) {
+ short ltype = aLeft->getResultType();
+ short rtype = aRight->getResultType();
+ nsresult rv = NS_OK;
+
+ // Handle case for just Left NodeSet or Both NodeSets
+ if (ltype == txAExprResult::NODESET) {
+ if (rtype == txAExprResult::BOOLEAN) {
+ BooleanResult leftBool(aLeft->booleanValue());
+ return compareResults(aContext, &leftBool, aRight);
+ }
+
+ txNodeSet* nodeSet = static_cast<txNodeSet*>(aLeft);
+ RefPtr<StringResult> strResult;
+ rv = aContext->recycler()->getStringResult(getter_AddRefs(strResult));
+ NS_ENSURE_SUCCESS(rv, false);
+
+ int32_t i;
+ for (i = 0; i < nodeSet->size(); ++i) {
+ strResult->mValue.Truncate();
+ txXPathNodeUtils::appendNodeValue(nodeSet->get(i), strResult->mValue);
+ if (compareResults(aContext, strResult, aRight)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ // Handle case for Just Right NodeSet
+ if (rtype == txAExprResult::NODESET) {
+ if (ltype == txAExprResult::BOOLEAN) {
+ BooleanResult rightBool(aRight->booleanValue());
+ return compareResults(aContext, aLeft, &rightBool);
+ }
+
+ txNodeSet* nodeSet = static_cast<txNodeSet*>(aRight);
+ RefPtr<StringResult> strResult;
+ rv = aContext->recycler()->getStringResult(getter_AddRefs(strResult));
+ NS_ENSURE_SUCCESS(rv, false);
+
+ int32_t i;
+ for (i = 0; i < nodeSet->size(); ++i) {
+ strResult->mValue.Truncate();
+ txXPathNodeUtils::appendNodeValue(nodeSet->get(i), strResult->mValue);
+ if (compareResults(aContext, aLeft, strResult)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ // Neither is a NodeSet
+ if (mOp == EQUAL || mOp == NOT_EQUAL) {
+ bool result;
+ const nsString *lString, *rString;
+
+ // If either is a bool, compare as bools.
+ if (ltype == txAExprResult::BOOLEAN || rtype == txAExprResult::BOOLEAN) {
+ result = aLeft->booleanValue() == aRight->booleanValue();
+ }
+
+ // If either is a number, compare as numbers.
+ else if (ltype == txAExprResult::NUMBER || rtype == txAExprResult::NUMBER) {
+ double lval = aLeft->numberValue();
+ double rval = aRight->numberValue();
+ result = (lval == rval);
+ }
+
+ // Otherwise compare as strings. Try to use the stringobject in
+ // StringResult if possible since that is a common case.
+ else if ((lString = aLeft->stringValuePointer())) {
+ if ((rString = aRight->stringValuePointer())) {
+ result = lString->Equals(*rString);
+ } else {
+ nsAutoString rStr;
+ aRight->stringValue(rStr);
+ result = lString->Equals(rStr);
+ }
+ } else if ((rString = aRight->stringValuePointer())) {
+ nsAutoString lStr;
+ aLeft->stringValue(lStr);
+ result = rString->Equals(lStr);
+ } else {
+ nsAutoString lStr, rStr;
+ aLeft->stringValue(lStr);
+ aRight->stringValue(rStr);
+ result = lStr.Equals(rStr);
+ }
+
+ return mOp == EQUAL ? result : !result;
+ }
+
+ double leftDbl = aLeft->numberValue();
+ double rightDbl = aRight->numberValue();
+ switch (mOp) {
+ case LESS_THAN: {
+ return (leftDbl < rightDbl);
+ }
+ case LESS_OR_EQUAL: {
+ return (leftDbl <= rightDbl);
+ }
+ case GREATER_THAN: {
+ return (leftDbl > rightDbl);
+ }
+ case GREATER_OR_EQUAL: {
+ return (leftDbl >= rightDbl);
+ }
+ default: {
+ MOZ_ASSERT_UNREACHABLE("We should have caught all cases");
+ }
+ }
+
+ return false;
+}
+
+nsresult RelationalExpr::evaluate(txIEvalContext* aContext,
+ txAExprResult** aResult) {
+ *aResult = nullptr;
+ RefPtr<txAExprResult> lResult;
+ nsresult rv = mLeftExpr->evaluate(aContext, getter_AddRefs(lResult));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ RefPtr<txAExprResult> rResult;
+ rv = mRightExpr->evaluate(aContext, getter_AddRefs(rResult));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aContext->recycler()->getBoolResult(
+ compareResults(aContext, lResult, rResult), aResult);
+
+ return NS_OK;
+}
+
+TX_IMPL_EXPR_STUBS_2(RelationalExpr, BOOLEAN_RESULT, mLeftExpr, mRightExpr)
+
+bool RelationalExpr::isSensitiveTo(ContextSensitivity aContext) {
+ return mLeftExpr->isSensitiveTo(aContext) ||
+ mRightExpr->isSensitiveTo(aContext);
+}
+
+#ifdef TX_TO_STRING
+void RelationalExpr::toString(nsAString& str) {
+ mLeftExpr->toString(str);
+
+ switch (mOp) {
+ case NOT_EQUAL:
+ str.AppendLiteral("!=");
+ break;
+ case LESS_THAN:
+ str.Append(char16_t('<'));
+ break;
+ case LESS_OR_EQUAL:
+ str.AppendLiteral("<=");
+ break;
+ case GREATER_THAN:
+ str.Append(char16_t('>'));
+ break;
+ case GREATER_OR_EQUAL:
+ str.AppendLiteral(">=");
+ break;
+ default:
+ str.Append(char16_t('='));
+ break;
+ }
+
+ mRightExpr->toString(str);
+}
+#endif
diff --git a/dom/xslt/xpath/txResultRecycler.cpp b/dom/xslt/xpath/txResultRecycler.cpp
new file mode 100644
index 0000000000..b52f91838a
--- /dev/null
+++ b/dom/xslt/xpath/txResultRecycler.cpp
@@ -0,0 +1,171 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txResultRecycler.h"
+#include "txExprResult.h"
+#include "txNodeSet.h"
+
+txResultRecycler::txResultRecycler()
+ : mEmptyStringResult(new StringResult(nullptr)),
+ mTrueResult(new BooleanResult(true)),
+ mFalseResult(new BooleanResult(false)) {}
+
+txResultRecycler::~txResultRecycler() {
+ txStackIterator stringIter(&mStringResults);
+ while (stringIter.hasNext()) {
+ delete static_cast<StringResult*>(stringIter.next());
+ }
+ txStackIterator nodesetIter(&mNodeSetResults);
+ while (nodesetIter.hasNext()) {
+ delete static_cast<txNodeSet*>(nodesetIter.next());
+ }
+ txStackIterator numberIter(&mNumberResults);
+ while (numberIter.hasNext()) {
+ delete static_cast<NumberResult*>(numberIter.next());
+ }
+}
+
+void txResultRecycler::recycle(txAExprResult* aResult) {
+ NS_ASSERTION(aResult->mRefCnt == 0, "In-use txAExprResult recycled");
+ RefPtr<txResultRecycler> kungFuDeathGrip;
+ aResult->mRecycler.swap(kungFuDeathGrip);
+
+ switch (aResult->getResultType()) {
+ case txAExprResult::STRING: {
+ mStringResults.push(static_cast<StringResult*>(aResult));
+ return;
+ }
+ case txAExprResult::NODESET: {
+ static_cast<txNodeSet*>(aResult)->clear();
+ mNodeSetResults.push(static_cast<txNodeSet*>(aResult));
+ return;
+ }
+ case txAExprResult::NUMBER: {
+ mNumberResults.push(static_cast<NumberResult*>(aResult));
+ return;
+ }
+ default: {
+ delete aResult;
+ }
+ }
+}
+
+nsresult txResultRecycler::getStringResult(StringResult** aResult) {
+ if (mStringResults.isEmpty()) {
+ *aResult = new StringResult(this);
+ } else {
+ *aResult = static_cast<StringResult*>(mStringResults.pop());
+ (*aResult)->mValue.Truncate();
+ (*aResult)->mRecycler = this;
+ }
+ NS_ADDREF(*aResult);
+
+ return NS_OK;
+}
+
+nsresult txResultRecycler::getStringResult(const nsAString& aValue,
+ txAExprResult** aResult) {
+ if (mStringResults.isEmpty()) {
+ *aResult = new StringResult(aValue, this);
+ } else {
+ StringResult* strRes = static_cast<StringResult*>(mStringResults.pop());
+ strRes->mValue = aValue;
+ strRes->mRecycler = this;
+ *aResult = strRes;
+ }
+ NS_ADDREF(*aResult);
+
+ return NS_OK;
+}
+
+void txResultRecycler::getEmptyStringResult(txAExprResult** aResult) {
+ *aResult = mEmptyStringResult;
+ NS_ADDREF(*aResult);
+}
+
+nsresult txResultRecycler::getNodeSet(txNodeSet** aResult) {
+ if (mNodeSetResults.isEmpty()) {
+ *aResult = new txNodeSet(this);
+ } else {
+ *aResult = static_cast<txNodeSet*>(mNodeSetResults.pop());
+ (*aResult)->mRecycler = this;
+ }
+ NS_ADDREF(*aResult);
+
+ return NS_OK;
+}
+
+nsresult txResultRecycler::getNodeSet(txNodeSet* aNodeSet,
+ txNodeSet** aResult) {
+ if (mNodeSetResults.isEmpty()) {
+ *aResult = new txNodeSet(*aNodeSet, this);
+ } else {
+ *aResult = static_cast<txNodeSet*>(mNodeSetResults.pop());
+ (*aResult)->append(*aNodeSet);
+ (*aResult)->mRecycler = this;
+ }
+ NS_ADDREF(*aResult);
+
+ return NS_OK;
+}
+
+nsresult txResultRecycler::getNodeSet(const txXPathNode& aNode,
+ txAExprResult** aResult) {
+ if (mNodeSetResults.isEmpty()) {
+ *aResult = new txNodeSet(aNode, this);
+ } else {
+ txNodeSet* nodes = static_cast<txNodeSet*>(mNodeSetResults.pop());
+ nodes->append(aNode);
+ nodes->mRecycler = this;
+ *aResult = nodes;
+ }
+ NS_ADDREF(*aResult);
+
+ return NS_OK;
+}
+
+nsresult txResultRecycler::getNumberResult(double aValue,
+ txAExprResult** aResult) {
+ if (mNumberResults.isEmpty()) {
+ *aResult = new NumberResult(aValue, this);
+ } else {
+ NumberResult* numRes = static_cast<NumberResult*>(mNumberResults.pop());
+ numRes->value = aValue;
+ numRes->mRecycler = this;
+ *aResult = numRes;
+ }
+ NS_ADDREF(*aResult);
+
+ return NS_OK;
+}
+
+void txResultRecycler::getBoolResult(bool aValue, txAExprResult** aResult) {
+ *aResult = aValue ? mTrueResult : mFalseResult;
+ NS_ADDREF(*aResult);
+}
+
+nsresult txResultRecycler::getNonSharedNodeSet(txNodeSet* aNodeSet,
+ txNodeSet** aResult) {
+ if (aNodeSet->mRefCnt > 1) {
+ return getNodeSet(aNodeSet, aResult);
+ }
+
+ *aResult = aNodeSet;
+ NS_ADDREF(*aResult);
+
+ return NS_OK;
+}
+
+void txAExprResult::Release() {
+ --mRefCnt;
+ NS_LOG_RELEASE(this, mRefCnt, "txAExprResult");
+ if (mRefCnt == 0) {
+ if (mRecycler) {
+ mRecycler->recycle(this);
+ } else {
+ delete this;
+ }
+ }
+}
diff --git a/dom/xslt/xpath/txResultRecycler.h b/dom/xslt/xpath/txResultRecycler.h
new file mode 100644
index 0000000000..f90687b70b
--- /dev/null
+++ b/dom/xslt/xpath/txResultRecycler.h
@@ -0,0 +1,76 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef txResultRecycler_h__
+#define txResultRecycler_h__
+
+#include "nsCOMPtr.h"
+#include "txStack.h"
+
+class txAExprResult;
+class StringResult;
+class txNodeSet;
+class txXPathNode;
+class NumberResult;
+class BooleanResult;
+
+class txResultRecycler {
+ public:
+ txResultRecycler();
+ ~txResultRecycler();
+
+ void AddRef() {
+ ++mRefCnt;
+ NS_LOG_ADDREF(this, mRefCnt, "txResultRecycler", sizeof(*this));
+ }
+ void Release() {
+ --mRefCnt;
+ NS_LOG_RELEASE(this, mRefCnt, "txResultRecycler");
+ if (mRefCnt == 0) {
+ mRefCnt = 1; // stabilize
+ delete this;
+ }
+ }
+
+ /**
+ * Returns an txAExprResult to this recycler for reuse.
+ * @param aResult result to recycle
+ */
+ void recycle(txAExprResult* aResult);
+
+ /**
+ * Functions to return results that will be fully used by the caller.
+ * Returns nullptr on out-of-memory and an inited result otherwise.
+ */
+ nsresult getStringResult(StringResult** aResult);
+ nsresult getStringResult(const nsAString& aValue, txAExprResult** aResult);
+ nsresult getNodeSet(txNodeSet** aResult);
+ nsresult getNodeSet(txNodeSet* aNodeSet, txNodeSet** aResult);
+ nsresult getNodeSet(const txXPathNode& aNode, txAExprResult** aResult);
+ nsresult getNumberResult(double aValue, txAExprResult** aResult);
+
+ /**
+ * Functions to return a txAExprResult that is shared across several
+ * clients and must not be modified. Never returns nullptr.
+ */
+ void getEmptyStringResult(txAExprResult** aResult);
+ void getBoolResult(bool aValue, txAExprResult** aResult);
+
+ /**
+ * Functions that return non-shared resultsobjects
+ */
+ nsresult getNonSharedNodeSet(txNodeSet* aNodeSet, txNodeSet** aResult);
+
+ private:
+ nsAutoRefCnt mRefCnt;
+ txStack mStringResults;
+ txStack mNodeSetResults;
+ txStack mNumberResults;
+ RefPtr<StringResult> mEmptyStringResult;
+ RefPtr<BooleanResult> mTrueResult;
+ RefPtr<BooleanResult> mFalseResult;
+};
+
+#endif // txResultRecycler_h__
diff --git a/dom/xslt/xpath/txRootExpr.cpp b/dom/xslt/xpath/txRootExpr.cpp
new file mode 100644
index 0000000000..cabc0e1c13
--- /dev/null
+++ b/dom/xslt/xpath/txRootExpr.cpp
@@ -0,0 +1,35 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txExpr.h"
+#include "txNodeSet.h"
+#include "txIXPathContext.h"
+#include "txXPathTreeWalker.h"
+
+/**
+ * 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 RootExpr::evaluate(txIEvalContext* aContext, txAExprResult** aResult) {
+ txXPathTreeWalker walker(aContext->getContextNode());
+ walker.moveToRoot();
+
+ return aContext->recycler()->getNodeSet(walker.getCurrentPosition(), aResult);
+}
+
+TX_IMPL_EXPR_STUBS_0(RootExpr, NODESET_RESULT)
+
+bool RootExpr::isSensitiveTo(ContextSensitivity aContext) {
+ return !!(aContext & NODE_CONTEXT);
+}
+
+#ifdef TX_TO_STRING
+void RootExpr::toString(nsAString& dest) {
+ if (mSerialize) dest.Append(char16_t('/'));
+}
+#endif
diff --git a/dom/xslt/xpath/txSingleNodeContext.h b/dom/xslt/xpath/txSingleNodeContext.h
new file mode 100644
index 0000000000..80b0680a2d
--- /dev/null
+++ b/dom/xslt/xpath/txSingleNodeContext.h
@@ -0,0 +1,64 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef __TX_XPATH_SINGLENODE_CONTEXT
+#define __TX_XPATH_SINGLENODE_CONTEXT
+
+#include "mozilla/Attributes.h"
+#include "txIXPathContext.h"
+
+class txSingleNodeContext : public txIEvalContext {
+ public:
+ txSingleNodeContext(const txXPathNode& aContextNode,
+ txIMatchContext* aContext)
+ : mNode(aContextNode), mInner(aContext) {
+ NS_ASSERTION(aContext, "txIMatchContext must be given");
+ }
+
+ nsresult getVariable(int32_t aNamespace, nsAtom* aLName,
+ txAExprResult*& aResult) override {
+ NS_ASSERTION(mInner, "mInner is null!!!");
+ return mInner->getVariable(aNamespace, aLName, aResult);
+ }
+
+ nsresult isStripSpaceAllowed(const txXPathNode& aNode,
+ bool& aAllowed) override {
+ NS_ASSERTION(mInner, "mInner is null!!!");
+ return mInner->isStripSpaceAllowed(aNode, aAllowed);
+ }
+
+ void* getPrivateContext() override {
+ NS_ASSERTION(mInner, "mInner is null!!!");
+ return mInner->getPrivateContext();
+ }
+
+ txResultRecycler* recycler() override {
+ NS_ASSERTION(mInner, "mInner is null!!!");
+ return mInner->recycler();
+ }
+
+ void receiveError(const nsAString& aMsg, nsresult aRes) override {
+ NS_ASSERTION(mInner, "mInner is null!!!");
+#ifdef DEBUG
+ nsAutoString error(u"forwarded error: "_ns);
+ error.Append(aMsg);
+ mInner->receiveError(error, aRes);
+#else
+ mInner->receiveError(aMsg, aRes);
+#endif
+ }
+
+ const txXPathNode& getContextNode() override { return mNode; }
+
+ uint32_t size() override { return 1; }
+
+ uint32_t position() override { return 1; }
+
+ private:
+ const txXPathNode& mNode;
+ txIMatchContext* mInner;
+};
+
+#endif // __TX_XPATH_SINGLENODE_CONTEXT
diff --git a/dom/xslt/xpath/txStringResult.cpp b/dom/xslt/xpath/txStringResult.cpp
new file mode 100644
index 0000000000..740b6f1b34
--- /dev/null
+++ b/dom/xslt/xpath/txStringResult.cpp
@@ -0,0 +1,43 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * StringResult
+ * Represents a String as a Result of evaluating an Expr
+ **/
+#include "txExprResult.h"
+
+/**
+ * Default Constructor
+ **/
+StringResult::StringResult(txResultRecycler* aRecycler)
+ : txAExprResult(aRecycler) {}
+
+/**
+ * Creates a new StringResult with the value of the given String parameter
+ * @param str the String to use for initialization of this StringResult's value
+ **/
+StringResult::StringResult(const nsAString& aValue, txResultRecycler* aRecycler)
+ : txAExprResult(aRecycler), mValue(aValue) {}
+
+/*
+ * Virtual Methods from ExprResult
+ */
+
+short StringResult::getResultType() {
+ return txAExprResult::STRING;
+} //-- getResultType
+
+void StringResult::stringValue(nsString& aResult) { aResult.Append(mValue); }
+
+const nsString* StringResult::stringValuePointer() { return &mValue; }
+
+bool StringResult::booleanValue() {
+ return !mValue.IsEmpty();
+} //-- booleanValue
+
+double StringResult::numberValue() {
+ return txDouble::toDouble(mValue);
+} //-- numberValue
diff --git a/dom/xslt/xpath/txUnaryExpr.cpp b/dom/xslt/xpath/txUnaryExpr.cpp
new file mode 100644
index 0000000000..ec31a5fcb3
--- /dev/null
+++ b/dom/xslt/xpath/txUnaryExpr.cpp
@@ -0,0 +1,49 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txExpr.h"
+#include "txIXPathContext.h"
+
+/*
+ * 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 UnaryExpr::evaluate(txIEvalContext* aContext,
+ txAExprResult** aResult) {
+ *aResult = nullptr;
+
+ RefPtr<txAExprResult> exprRes;
+ nsresult rv = expr->evaluate(aContext, getter_AddRefs(exprRes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ double value = exprRes->numberValue();
+#ifdef HPUX
+ /*
+ * Negation of a zero doesn't produce a negative
+ * zero on HPUX. Perform the operation by multiplying with
+ * -1.
+ */
+ return aContext->recycler()->getNumberResult(-1 * value, aResult);
+#else
+ return aContext->recycler()->getNumberResult(-value, aResult);
+#endif
+}
+
+TX_IMPL_EXPR_STUBS_1(UnaryExpr, NODESET_RESULT, expr)
+
+bool UnaryExpr::isSensitiveTo(ContextSensitivity aContext) {
+ return expr->isSensitiveTo(aContext);
+}
+
+#ifdef TX_TO_STRING
+void UnaryExpr::toString(nsAString& str) {
+ if (!expr) return;
+ str.Append(char16_t('-'));
+ expr->toString(str);
+}
+#endif
diff --git a/dom/xslt/xpath/txUnionExpr.cpp b/dom/xslt/xpath/txUnionExpr.cpp
new file mode 100644
index 0000000000..be8fa47781
--- /dev/null
+++ b/dom/xslt/xpath/txUnionExpr.cpp
@@ -0,0 +1,85 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txExpr.h"
+#include "txIXPathContext.h"
+#include "txNodeSet.h"
+
+#ifdef TX_TO_STRING
+# include "nsReadableUtils.h"
+#endif
+
+//-------------/
+//- UnionExpr -/
+//-------------/
+
+//-----------------------------/
+//- Virtual methods from Expr -/
+//-----------------------------/
+
+/**
+ * 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 UnionExpr::evaluate(txIEvalContext* aContext,
+ txAExprResult** aResult) {
+ *aResult = nullptr;
+ RefPtr<txNodeSet> nodes;
+ nsresult rv = aContext->recycler()->getNodeSet(getter_AddRefs(nodes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ uint32_t i, len = mExpressions.Length();
+ for (i = 0; i < len; ++i) {
+ RefPtr<txAExprResult> exprResult;
+ rv = mExpressions[i]->evaluate(aContext, getter_AddRefs(exprResult));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (exprResult->getResultType() != txAExprResult::NODESET) {
+ // XXX ErrorReport: report nonnodeset error
+ return NS_ERROR_XSLT_NODESET_EXPECTED;
+ }
+
+ RefPtr<txNodeSet> resultSet, ownedSet;
+ resultSet =
+ static_cast<txNodeSet*>(static_cast<txAExprResult*>(exprResult));
+ exprResult = nullptr;
+ rv = aContext->recycler()->getNonSharedNodeSet(resultSet,
+ getter_AddRefs(ownedSet));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = nodes->addAndTransfer(ownedSet);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ *aResult = nodes;
+ NS_ADDREF(*aResult);
+
+ return NS_OK;
+} //-- evaluate
+
+Expr::ExprType UnionExpr::getType() { return UNION_EXPR; }
+
+TX_IMPL_EXPR_STUBS_LIST(UnionExpr, NODESET_RESULT, mExpressions)
+
+bool UnionExpr::isSensitiveTo(ContextSensitivity aContext) {
+ uint32_t i, len = mExpressions.Length();
+ for (i = 0; i < len; ++i) {
+ if (mExpressions[i]->isSensitiveTo(aContext)) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+#ifdef TX_TO_STRING
+void UnionExpr::toString(nsAString& aDest) {
+ StringJoinAppend(aDest, u" | "_ns, mExpressions,
+ [](nsAString& dest, Expr* expr) { expr->toString(dest); });
+}
+#endif
diff --git a/dom/xslt/xpath/txUnionNodeTest.cpp b/dom/xslt/xpath/txUnionNodeTest.cpp
new file mode 100644
index 0000000000..4461b537e4
--- /dev/null
+++ b/dom/xslt/xpath/txUnionNodeTest.cpp
@@ -0,0 +1,59 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/FloatingPoint.h"
+
+#include "txExpr.h"
+#include "txExprResult.h"
+#include "txSingleNodeContext.h"
+
+#ifdef TX_TO_STRING
+# include "nsReadableUtils.h"
+#endif
+
+nsresult txUnionNodeTest::matches(const txXPathNode& aNode,
+ txIMatchContext* aContext, bool& aMatched) {
+ uint32_t i, len = mNodeTests.Length();
+ for (i = 0; i < len; ++i) {
+ nsresult rv = mNodeTests[i]->matches(aNode, aContext, aMatched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (aMatched) {
+ return NS_OK;
+ }
+ }
+
+ aMatched = false;
+ return NS_OK;
+}
+
+double txUnionNodeTest::getDefaultPriority() {
+ NS_ERROR("Don't call getDefaultPriority on txUnionPattern");
+ return mozilla::UnspecifiedNaN<double>();
+}
+
+bool txUnionNodeTest::isSensitiveTo(Expr::ContextSensitivity aContext) {
+ uint32_t i, len = mNodeTests.Length();
+ for (i = 0; i < len; ++i) {
+ if (mNodeTests[i]->isSensitiveTo(aContext)) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+#ifdef TX_TO_STRING
+void txUnionNodeTest::toString(nsAString& aDest) {
+ aDest.Append('(');
+
+ StringJoinAppend(
+ aDest, u" | "_ns, mNodeTests,
+ [](nsAString& dest, txNodeTest* nodeTest) { nodeTest->toString(dest); });
+
+ aDest.Append(')');
+}
+#endif
diff --git a/dom/xslt/xpath/txVariableRefExpr.cpp b/dom/xslt/xpath/txVariableRefExpr.cpp
new file mode 100644
index 0000000000..4836913135
--- /dev/null
+++ b/dom/xslt/xpath/txVariableRefExpr.cpp
@@ -0,0 +1,62 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txExpr.h"
+#include "nsAtom.h"
+#include "txNodeSet.h"
+#include "nsGkAtoms.h"
+#include "txIXPathContext.h"
+
+//-------------------/
+//- VariableRefExpr -/
+//-------------------/
+
+/**
+ * Creates a VariableRefExpr with the given variable name
+ **/
+VariableRefExpr::VariableRefExpr(nsAtom* aPrefix, nsAtom* aLocalName,
+ int32_t aNSID)
+ : mPrefix(aPrefix), mLocalName(aLocalName), mNamespace(aNSID) {
+ NS_ASSERTION(mLocalName, "VariableRefExpr without local name?");
+ if (mPrefix == nsGkAtoms::_empty) mPrefix = nullptr;
+}
+
+/**
+ * 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 VariableRefExpr::evaluate(txIEvalContext* aContext,
+ txAExprResult** aResult) {
+ nsresult rv = aContext->getVariable(mNamespace, mLocalName, *aResult);
+ if (NS_FAILED(rv)) {
+ // XXX report error, undefined variable
+ return rv;
+ }
+ return NS_OK;
+}
+
+TX_IMPL_EXPR_STUBS_0(VariableRefExpr, ANY_RESULT)
+
+bool VariableRefExpr::isSensitiveTo(ContextSensitivity aContext) {
+ return !!(aContext & VARIABLES_CONTEXT);
+}
+
+#ifdef TX_TO_STRING
+void VariableRefExpr::toString(nsAString& aDest) {
+ aDest.Append(char16_t('$'));
+ if (mPrefix) {
+ nsAutoString prefix;
+ mPrefix->ToString(prefix);
+ aDest.Append(prefix);
+ aDest.Append(char16_t(':'));
+ }
+ nsAutoString lname;
+ mLocalName->ToString(lname);
+ aDest.Append(lname);
+}
+#endif
diff --git a/dom/xslt/xpath/txXPathNode.h b/dom/xslt/xpath/txXPathNode.h
new file mode 100644
index 0000000000..8c5d6f5308
--- /dev/null
+++ b/dom/xslt/xpath/txXPathNode.h
@@ -0,0 +1,91 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef txXPathNode_h__
+#define txXPathNode_h__
+
+#include "nsIContent.h"
+#include "mozilla/dom/Document.h"
+#include "nsINode.h"
+#include "nsNameSpaceManager.h"
+
+using txXPathNodeType = nsINode;
+
+class txXPathNode {
+ public:
+ bool operator==(const txXPathNode& aNode) const;
+ bool operator!=(const txXPathNode& aNode) const { return !(*this == aNode); }
+ ~txXPathNode();
+
+ private:
+ friend class txNodeSet;
+ friend class txXPathNativeNode;
+ friend class txXPathNodeUtils;
+ friend class txXPathTreeWalker;
+
+ txXPathNode(const txXPathNode& aNode);
+
+ explicit txXPathNode(mozilla::dom::Document* aDocument)
+ : mNode(aDocument), mRefCountRoot(0), mIndex(eDocument) {
+ MOZ_COUNT_CTOR(txXPathNode);
+ }
+ txXPathNode(nsINode* aNode, uint32_t aIndex, nsINode* aRoot)
+ : mNode(aNode), mRefCountRoot(aRoot ? 1 : 0), mIndex(aIndex) {
+ MOZ_COUNT_CTOR(txXPathNode);
+ if (aRoot) {
+ NS_ADDREF(aRoot);
+ }
+ }
+
+ static nsINode* RootOf(nsINode* aNode) { return aNode->SubtreeRoot(); }
+ nsINode* Root() const { return RootOf(mNode); }
+ nsINode* GetRootToAddRef() const { return mRefCountRoot ? Root() : nullptr; }
+
+ bool isDocument() const { return mIndex == eDocument; }
+ bool isContent() const { return mIndex == eContent; }
+ bool isAttribute() const { return mIndex != eDocument && mIndex != eContent; }
+
+ nsIContent* Content() const {
+ NS_ASSERTION(isContent() || isAttribute(), "wrong type");
+ return static_cast<nsIContent*>(mNode);
+ }
+ mozilla::dom::Document* Document() const {
+ NS_ASSERTION(isDocument(), "wrong type");
+ return static_cast<mozilla::dom::Document*>(mNode);
+ }
+
+ enum PositionType { eDocument = (1 << 30), eContent = eDocument - 1 };
+
+ nsINode* mNode;
+ uint32_t mRefCountRoot : 1;
+ uint32_t mIndex : 31;
+};
+
+class txNamespaceManager {
+ public:
+ static int32_t getNamespaceID(const nsAString& aNamespaceURI);
+ static nsresult getNamespaceURI(const int32_t aID, nsAString& aResult);
+};
+
+/* static */
+inline int32_t txNamespaceManager::getNamespaceID(
+ const nsAString& aNamespaceURI) {
+ int32_t namespaceID = kNameSpaceID_Unknown;
+ nsNameSpaceManager::GetInstance()->RegisterNameSpace(aNamespaceURI,
+ namespaceID);
+ return namespaceID;
+}
+
+/* static */
+inline nsresult txNamespaceManager::getNamespaceURI(const int32_t aID,
+ nsAString& aResult) {
+ return nsNameSpaceManager::GetInstance()->GetNameSpaceURI(aID, aResult);
+}
+
+inline bool txXPathNode::operator==(const txXPathNode& aNode) const {
+ return mIndex == aNode.mIndex && mNode == aNode.mNode;
+}
+
+#endif /* txXPathNode_h__ */
diff --git a/dom/xslt/xpath/txXPathOptimizer.cpp b/dom/xslt/xpath/txXPathOptimizer.cpp
new file mode 100644
index 0000000000..40a94f674c
--- /dev/null
+++ b/dom/xslt/xpath/txXPathOptimizer.cpp
@@ -0,0 +1,246 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/Assertions.h"
+#include "txXPathOptimizer.h"
+#include "txExprResult.h"
+#include "nsAtom.h"
+#include "nsGkAtoms.h"
+#include "txXPathNode.h"
+#include "txExpr.h"
+#include "txIXPathContext.h"
+
+using mozilla::UniquePtr;
+using mozilla::Unused;
+
+class txEarlyEvalContext : public txIEvalContext {
+ public:
+ explicit txEarlyEvalContext(txResultRecycler* aRecycler)
+ : mRecycler(aRecycler) {}
+
+ // txIEvalContext
+ nsresult getVariable(int32_t aNamespace, nsAtom* aLName,
+ txAExprResult*& aResult) override {
+ MOZ_CRASH("shouldn't depend on this context");
+ }
+ nsresult isStripSpaceAllowed(const txXPathNode& aNode,
+ bool& aAllowed) override {
+ MOZ_CRASH("shouldn't depend on this context");
+ }
+ void* getPrivateContext() override {
+ MOZ_CRASH("shouldn't depend on this context");
+ }
+ txResultRecycler* recycler() override { return mRecycler; }
+ void receiveError(const nsAString& aMsg, nsresult aRes) override {}
+ const txXPathNode& getContextNode() override {
+ MOZ_CRASH("shouldn't depend on this context");
+ }
+ uint32_t size() override { MOZ_CRASH("shouldn't depend on this context"); }
+ uint32_t position() override {
+ MOZ_CRASH("shouldn't depend on this context");
+ }
+
+ private:
+ txResultRecycler* mRecycler;
+};
+
+void txXPathOptimizer::optimize(Expr* aInExpr, Expr** aOutExpr) {
+ *aOutExpr = nullptr;
+
+ // First check if the expression will produce the same result
+ // under any context.
+ Expr::ExprType exprType = aInExpr->getType();
+ if (exprType != Expr::LITERAL_EXPR &&
+ !aInExpr->isSensitiveTo(Expr::ANY_CONTEXT)) {
+ RefPtr<txResultRecycler> recycler = new txResultRecycler;
+ txEarlyEvalContext context(recycler);
+ RefPtr<txAExprResult> exprRes;
+
+ // Don't throw if this fails since it could be that the expression
+ // is or contains an error-expression.
+ nsresult rv = aInExpr->evaluate(&context, getter_AddRefs(exprRes));
+ if (NS_SUCCEEDED(rv)) {
+ *aOutExpr = new txLiteralExpr(exprRes);
+ }
+
+ return;
+ }
+
+ // Then optimize sub expressions
+ uint32_t i = 0;
+ Expr* subExpr;
+ while ((subExpr = aInExpr->getSubExprAt(i))) {
+ Expr* newExpr = nullptr;
+ optimize(subExpr, &newExpr);
+ if (newExpr) {
+ delete subExpr;
+ aInExpr->setSubExprAt(i, newExpr);
+ }
+
+ ++i;
+ }
+
+ // Finally see if current expression can be optimized
+ switch (exprType) {
+ case Expr::LOCATIONSTEP_EXPR:
+ optimizeStep(aInExpr, aOutExpr);
+ return;
+
+ case Expr::PATH_EXPR:
+ optimizePath(aInExpr, aOutExpr);
+ return;
+
+ case Expr::UNION_EXPR:
+ optimizeUnion(aInExpr, aOutExpr);
+ return;
+
+ default:
+ return;
+ }
+}
+
+void txXPathOptimizer::optimizeStep(Expr* aInExpr, Expr** aOutExpr) {
+ LocationStep* step = static_cast<LocationStep*>(aInExpr);
+
+ if (step->getAxisIdentifier() == LocationStep::ATTRIBUTE_AXIS) {
+ // Test for @foo type steps.
+ txNameTest* nameTest = nullptr;
+ if (!step->getSubExprAt(0) &&
+ step->getNodeTest()->getType() == txNameTest::NAME_TEST &&
+ (nameTest = static_cast<txNameTest*>(step->getNodeTest()))
+ ->mLocalName != nsGkAtoms::_asterisk) {
+ *aOutExpr = new txNamedAttributeStep(
+ nameTest->mNamespace, nameTest->mPrefix, nameTest->mLocalName);
+ return; // return since we no longer have a step-object.
+ }
+ }
+
+ // Test for predicates that can be combined into the nodetest
+ Expr* pred;
+ while ((pred = step->getSubExprAt(0)) &&
+ !pred->canReturnType(Expr::NUMBER_RESULT) &&
+ !pred->isSensitiveTo(Expr::NODESET_CONTEXT)) {
+ txNodeTest* predTest = new txPredicatedNodeTest(step->getNodeTest(), pred);
+ step->dropFirst();
+ step->setNodeTest(predTest);
+ }
+}
+
+void txXPathOptimizer::optimizePath(Expr* aInExpr, Expr** aOutExpr) {
+ PathExpr* path = static_cast<PathExpr*>(aInExpr);
+
+ uint32_t i;
+ Expr* subExpr;
+ // look for steps like "//foo" that can be turned into "/descendant::foo"
+ // and "//." that can be turned into "/descendant-or-self::node()"
+ for (i = 0; (subExpr = path->getSubExprAt(i)); ++i) {
+ if (path->getPathOpAt(i) == PathExpr::DESCENDANT_OP &&
+ subExpr->getType() == Expr::LOCATIONSTEP_EXPR &&
+ !subExpr->getSubExprAt(0)) {
+ LocationStep* step = static_cast<LocationStep*>(subExpr);
+ if (step->getAxisIdentifier() == LocationStep::CHILD_AXIS) {
+ step->setAxisIdentifier(LocationStep::DESCENDANT_AXIS);
+ path->setPathOpAt(i, PathExpr::RELATIVE_OP);
+ } else if (step->getAxisIdentifier() == LocationStep::SELF_AXIS) {
+ step->setAxisIdentifier(LocationStep::DESCENDANT_OR_SELF_AXIS);
+ path->setPathOpAt(i, PathExpr::RELATIVE_OP);
+ }
+ }
+ }
+
+ // look for expressions that start with a "./"
+ subExpr = path->getSubExprAt(0);
+ LocationStep* step;
+ if (subExpr->getType() == Expr::LOCATIONSTEP_EXPR && path->getSubExprAt(1) &&
+ path->getPathOpAt(1) != PathExpr::DESCENDANT_OP) {
+ step = static_cast<LocationStep*>(subExpr);
+ if (step->getAxisIdentifier() == LocationStep::SELF_AXIS &&
+ !step->getSubExprAt(0)) {
+ txNodeTest* test = step->getNodeTest();
+ if (test->getType() == txNodeTest::NODETYPE_TEST &&
+ (static_cast<txNodeTypeTest*>(test))->getNodeTestType() ==
+ txNodeTypeTest::NODE_TYPE) {
+ // We have a '.' as first step followed by a single '/'.
+
+ // Check if there are only two steps. If so, return the second
+ // as resulting expression.
+ if (!path->getSubExprAt(2)) {
+ *aOutExpr = path->getSubExprAt(1);
+ path->setSubExprAt(1, nullptr);
+
+ return;
+ }
+
+ // Just delete the '.' step and leave the rest of the PathExpr
+ path->deleteExprAt(0);
+ }
+ }
+ }
+}
+
+void txXPathOptimizer::optimizeUnion(Expr* aInExpr, Expr** aOutExpr) {
+ UnionExpr* uni = static_cast<UnionExpr*>(aInExpr);
+
+ // Check for expressions like "foo | bar" and
+ // "descendant::foo | descendant::bar"
+
+ uint32_t current;
+ Expr* subExpr;
+ for (current = 0; (subExpr = uni->getSubExprAt(current)); ++current) {
+ if (subExpr->getType() != Expr::LOCATIONSTEP_EXPR ||
+ subExpr->getSubExprAt(0)) {
+ continue;
+ }
+
+ LocationStep* currentStep = static_cast<LocationStep*>(subExpr);
+ LocationStep::LocationStepType axis = currentStep->getAxisIdentifier();
+
+ txUnionNodeTest* unionTest = nullptr;
+
+ // Check if there are any other steps with the same axis and merge
+ // them with currentStep
+ uint32_t i;
+ for (i = current + 1; (subExpr = uni->getSubExprAt(i)); ++i) {
+ if (subExpr->getType() != Expr::LOCATIONSTEP_EXPR ||
+ subExpr->getSubExprAt(0)) {
+ continue;
+ }
+
+ LocationStep* step = static_cast<LocationStep*>(subExpr);
+ if (step->getAxisIdentifier() != axis) {
+ continue;
+ }
+
+ // Create a txUnionNodeTest if needed
+ if (!unionTest) {
+ UniquePtr<txNodeTest> owner(unionTest = new txUnionNodeTest);
+ unionTest->addNodeTest(currentStep->getNodeTest());
+
+ currentStep->setNodeTest(unionTest);
+ Unused << owner.release();
+ }
+
+ // Merge the nodetest into the union
+ unionTest->addNodeTest(step->getNodeTest());
+
+ step->setNodeTest(nullptr);
+
+ // Remove the step from the UnionExpr
+ uni->deleteExprAt(i);
+ --i;
+ }
+
+ // Check if all expressions were merged into a single step. If so,
+ // return the step as the new expression.
+ if (unionTest && current == 0 && !uni->getSubExprAt(1)) {
+ // Make sure the step doesn't get deleted when the UnionExpr is
+ uni->setSubExprAt(0, nullptr);
+ *aOutExpr = currentStep;
+
+ // Return right away since we no longer have a union
+ return;
+ }
+ }
+}
diff --git a/dom/xslt/xpath/txXPathOptimizer.h b/dom/xslt/xpath/txXPathOptimizer.h
new file mode 100644
index 0000000000..84f00191e7
--- /dev/null
+++ b/dom/xslt/xpath/txXPathOptimizer.h
@@ -0,0 +1,30 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef txXPathOptimizer_h__
+#define txXPathOptimizer_h__
+
+#include "txCore.h"
+
+class Expr;
+
+class txXPathOptimizer {
+ public:
+ /**
+ * Optimize the given expression.
+ * @param aInExpr Expression to optimize.
+ * @param aOutExpr Resulting expression, null if optimization didn't
+ * result in a new expression.
+ */
+ void optimize(Expr* aInExpr, Expr** aOutExpr);
+
+ private:
+ // Helper methods for optimizing specific classes
+ void optimizeStep(Expr* aInExpr, Expr** aOutExpr);
+ void optimizePath(Expr* aInExpr, Expr** aOutExpr);
+ void optimizeUnion(Expr* aInExpr, Expr** aOutExpr);
+};
+
+#endif
diff --git a/dom/xslt/xpath/txXPathTreeWalker.h b/dom/xslt/xpath/txXPathTreeWalker.h
new file mode 100644
index 0000000000..6b74b1e18d
--- /dev/null
+++ b/dom/xslt/xpath/txXPathTreeWalker.h
@@ -0,0 +1,201 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef txXPathTreeWalker_h__
+#define txXPathTreeWalker_h__
+
+#include "txCore.h"
+#include "txXPathNode.h"
+#include "nsIContentInlines.h"
+#include "nsTArray.h"
+
+class nsAtom;
+
+class txXPathTreeWalker {
+ public:
+ txXPathTreeWalker(const txXPathTreeWalker& aOther);
+ explicit txXPathTreeWalker(const txXPathNode& aNode);
+
+ bool getAttr(nsAtom* aLocalName, int32_t aNSID, nsAString& aValue) const;
+ int32_t getNamespaceID() const;
+ uint16_t getNodeType() const;
+ void appendNodeValue(nsAString& aResult) const;
+ void getNodeName(nsAString& aName) const;
+
+ void moveTo(const txXPathTreeWalker& aWalker);
+
+ void moveToRoot();
+ bool moveToParent();
+ bool moveToElementById(const nsAString& aID);
+ bool moveToFirstAttribute();
+ bool moveToNextAttribute();
+ bool moveToNamedAttribute(nsAtom* aLocalName, int32_t aNSID);
+ bool moveToFirstChild();
+ bool moveToLastChild();
+ bool moveToNextSibling();
+ bool moveToPreviousSibling();
+
+ bool isOnNode(const txXPathNode& aNode) const;
+
+ const txXPathNode& getCurrentPosition() const;
+
+ private:
+ txXPathNode mPosition;
+
+ bool moveToValidAttribute(uint32_t aStartIndex);
+};
+
+class txXPathNodeUtils {
+ public:
+ static bool getAttr(const txXPathNode& aNode, nsAtom* aLocalName,
+ int32_t aNSID, nsAString& aValue);
+ static already_AddRefed<nsAtom> getLocalName(const txXPathNode& aNode);
+ static nsAtom* getPrefix(const txXPathNode& aNode);
+ static void getLocalName(const txXPathNode& aNode, nsAString& aLocalName);
+ static void getNodeName(const txXPathNode& aNode, nsAString& aName);
+ static int32_t getNamespaceID(const txXPathNode& aNode);
+ static void getNamespaceURI(const txXPathNode& aNode, nsAString& aURI);
+ static uint16_t getNodeType(const txXPathNode& aNode);
+ static void appendNodeValue(const txXPathNode& aNode, nsAString& aResult);
+ static bool isWhitespace(const txXPathNode& aNode);
+ static txXPathNode* getOwnerDocument(const txXPathNode& aNode);
+ static int32_t getUniqueIdentifier(const txXPathNode& aNode);
+ static nsresult getXSLTId(const txXPathNode& aNode, const txXPathNode& aBase,
+ nsAString& aResult);
+ static void release(txXPathNode* aNode);
+ static nsresult getBaseURI(const txXPathNode& aNode, nsAString& aURI);
+ static int comparePosition(const txXPathNode& aNode,
+ const txXPathNode& aOtherNode);
+ static bool localNameEquals(const txXPathNode& aNode, nsAtom* aLocalName);
+ static bool isRoot(const txXPathNode& aNode);
+ static bool isElement(const txXPathNode& aNode);
+ static bool isAttribute(const txXPathNode& aNode);
+ static bool isProcessingInstruction(const txXPathNode& aNode);
+ static bool isComment(const txXPathNode& aNode);
+ static bool isText(const txXPathNode& aNode);
+ static inline bool isHTMLElementInHTMLDocument(const txXPathNode& aNode) {
+ if (!aNode.isContent()) {
+ return false;
+ }
+ nsIContent* content = aNode.Content();
+ return content->IsHTMLElement() && content->IsInHTMLDocument();
+ }
+};
+
+class txXPathNativeNode {
+ public:
+ static txXPathNode* createXPathNode(nsINode* aNode,
+ bool aKeepRootAlive = false);
+ static txXPathNode* createXPathNode(nsIContent* aContent,
+ bool aKeepRootAlive = false);
+ static txXPathNode* createXPathNode(mozilla::dom::Document* aDocument);
+ static nsINode* getNode(const txXPathNode& aNode);
+ static nsIContent* getContent(const txXPathNode& aNode);
+ static mozilla::dom::Document* getDocument(const txXPathNode& aNode);
+ static void addRef(const txXPathNode& aNode) { NS_ADDREF(aNode.mNode); }
+ static void release(const txXPathNode& aNode) {
+ nsINode* node = aNode.mNode;
+ NS_RELEASE(node);
+ }
+};
+
+inline const txXPathNode& txXPathTreeWalker::getCurrentPosition() const {
+ return mPosition;
+}
+
+inline bool txXPathTreeWalker::getAttr(nsAtom* aLocalName, int32_t aNSID,
+ nsAString& aValue) const {
+ return txXPathNodeUtils::getAttr(mPosition, aLocalName, aNSID, aValue);
+}
+
+inline int32_t txXPathTreeWalker::getNamespaceID() const {
+ return txXPathNodeUtils::getNamespaceID(mPosition);
+}
+
+inline void txXPathTreeWalker::appendNodeValue(nsAString& aResult) const {
+ txXPathNodeUtils::appendNodeValue(mPosition, aResult);
+}
+
+inline void txXPathTreeWalker::getNodeName(nsAString& aName) const {
+ txXPathNodeUtils::getNodeName(mPosition, aName);
+}
+
+inline void txXPathTreeWalker::moveTo(const txXPathTreeWalker& aWalker) {
+ nsINode* root = nullptr;
+ if (mPosition.mRefCountRoot) {
+ root = mPosition.Root();
+ }
+ mPosition.mIndex = aWalker.mPosition.mIndex;
+ mPosition.mRefCountRoot = aWalker.mPosition.mRefCountRoot;
+ mPosition.mNode = aWalker.mPosition.mNode;
+ nsINode* newRoot = nullptr;
+ if (mPosition.mRefCountRoot) {
+ newRoot = mPosition.Root();
+ }
+ if (root != newRoot) {
+ NS_IF_ADDREF(newRoot);
+ NS_IF_RELEASE(root);
+ }
+}
+
+inline bool txXPathTreeWalker::isOnNode(const txXPathNode& aNode) const {
+ return (mPosition == aNode);
+}
+
+/* static */
+inline int32_t txXPathNodeUtils::getUniqueIdentifier(const txXPathNode& aNode) {
+ MOZ_ASSERT(!aNode.isAttribute(), "Not implemented for attributes.");
+ return NS_PTR_TO_INT32(aNode.mNode);
+}
+
+/* static */
+inline void txXPathNodeUtils::release(txXPathNode* aNode) {
+ NS_RELEASE(aNode->mNode);
+}
+
+/* static */
+inline bool txXPathNodeUtils::localNameEquals(const txXPathNode& aNode,
+ nsAtom* aLocalName) {
+ if (aNode.isContent() && aNode.Content()->IsElement()) {
+ return aNode.Content()->NodeInfo()->Equals(aLocalName);
+ }
+
+ RefPtr<nsAtom> localName = txXPathNodeUtils::getLocalName(aNode);
+
+ return localName == aLocalName;
+}
+
+/* static */
+inline bool txXPathNodeUtils::isRoot(const txXPathNode& aNode) {
+ return !aNode.isAttribute() && !aNode.mNode->GetParentNode();
+}
+
+/* static */
+inline bool txXPathNodeUtils::isElement(const txXPathNode& aNode) {
+ return aNode.isContent() && aNode.Content()->IsElement();
+}
+
+/* static */
+inline bool txXPathNodeUtils::isAttribute(const txXPathNode& aNode) {
+ return aNode.isAttribute();
+}
+
+/* static */
+inline bool txXPathNodeUtils::isProcessingInstruction(
+ const txXPathNode& aNode) {
+ return aNode.isContent() && aNode.Content()->IsProcessingInstruction();
+}
+
+/* static */
+inline bool txXPathNodeUtils::isComment(const txXPathNode& aNode) {
+ return aNode.isContent() && aNode.Content()->IsComment();
+}
+
+/* static */
+inline bool txXPathNodeUtils::isText(const txXPathNode& aNode) {
+ return aNode.isContent() && aNode.Content()->IsText();
+}
+
+#endif /* txXPathTreeWalker_h__ */
diff --git a/dom/xslt/xslt/moz.build b/dom/xslt/xslt/moz.build
new file mode 100644
index 0000000000..ab0e6e4aa3
--- /dev/null
+++ b/dom/xslt/xslt/moz.build
@@ -0,0 +1,66 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+EXPORTS.mozilla.dom += [
+ "txMozillaXSLTProcessor.h",
+ "txXSLTMsgsURL.h",
+]
+
+XPIDL_MODULE = "dom_xslt"
+
+XPIDL_SOURCES += [
+ "txIEXSLTFunctions.idl",
+]
+
+UNIFIED_SOURCES += [
+ "txBufferingHandler.cpp",
+ "txCurrentFunctionCall.cpp",
+ "txDocumentFunctionCall.cpp",
+ "txExecutionState.cpp",
+ "txEXSLTFunctions.cpp",
+ "txFormatNumberFunctionCall.cpp",
+ "txGenerateIdFunctionCall.cpp",
+ "txInstructions.cpp",
+ "txKeyFunctionCall.cpp",
+ "txMozillaStylesheetCompiler.cpp",
+ "txMozillaTextOutput.cpp",
+ "txMozillaXMLOutput.cpp",
+ "txMozillaXSLTProcessor.cpp",
+ "txNodeSorter.cpp",
+ "txOutputFormat.cpp",
+ "txPatternOptimizer.cpp",
+ "txPatternParser.cpp",
+ "txRtfHandler.cpp",
+ "txStylesheet.cpp",
+ "txStylesheetCompileHandlers.cpp",
+ "txStylesheetCompiler.cpp",
+ "txTextHandler.cpp",
+ "txToplevelItems.cpp",
+ "txUnknownHandler.cpp",
+ "txXPathResultComparator.cpp",
+ "txXSLTEnvironmentFunctionCall.cpp",
+ "txXSLTNumber.cpp",
+ "txXSLTNumberCounters.cpp",
+ "txXSLTPatterns.cpp",
+ "txXSLTProcessor.cpp",
+]
+
+EXTRA_JS_MODULES += [
+ "txEXSLTRegExFunctions.sys.mjs",
+]
+
+include("/ipc/chromium/chromium-config.mozbuild")
+
+LOCAL_INCLUDES += [
+ "../base",
+ "../xml",
+ "../xpath",
+ "/dom/base",
+ "/js/xpconnect/src",
+ "/parser/htmlparser",
+]
+
+FINAL_LIBRARY = "xul"
diff --git a/dom/xslt/xslt/txBufferingHandler.cpp b/dom/xslt/xslt/txBufferingHandler.cpp
new file mode 100644
index 0000000000..a0c7a39f73
--- /dev/null
+++ b/dom/xslt/xslt/txBufferingHandler.cpp
@@ -0,0 +1,385 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txBufferingHandler.h"
+
+using mozilla::MakeUnique;
+
+class txOutputTransaction {
+ public:
+ enum txTransactionType {
+ eAttributeTransaction,
+ eAttributeAtomTransaction,
+ eCharacterTransaction,
+ eCharacterNoOETransaction,
+ eCommentTransaction,
+ eEndDocumentTransaction,
+ eEndElementTransaction,
+ ePITransaction,
+ eStartDocumentTransaction,
+ eStartElementAtomTransaction,
+ eStartElementTransaction
+ };
+ explicit txOutputTransaction(txTransactionType aType) : mType(aType) {
+ MOZ_COUNT_CTOR(txOutputTransaction);
+ }
+ MOZ_COUNTED_DTOR_VIRTUAL(txOutputTransaction)
+ txTransactionType mType;
+};
+
+class txCharacterTransaction : public txOutputTransaction {
+ public:
+ txCharacterTransaction(txTransactionType aType, uint32_t aLength)
+ : txOutputTransaction(aType), mLength(aLength) {
+ MOZ_COUNT_CTOR_INHERITED(txCharacterTransaction, txOutputTransaction);
+ }
+ virtual ~txCharacterTransaction() {
+ MOZ_COUNT_DTOR_INHERITED(txCharacterTransaction, txOutputTransaction);
+ }
+ uint32_t mLength;
+};
+
+class txCommentTransaction : public txOutputTransaction {
+ public:
+ explicit txCommentTransaction(const nsAString& aValue)
+ : txOutputTransaction(eCommentTransaction), mValue(aValue) {
+ MOZ_COUNT_CTOR_INHERITED(txCommentTransaction, txOutputTransaction);
+ }
+ virtual ~txCommentTransaction() {
+ MOZ_COUNT_DTOR_INHERITED(txCommentTransaction, txOutputTransaction);
+ }
+ nsString mValue;
+};
+
+class txPITransaction : public txOutputTransaction {
+ public:
+ txPITransaction(const nsAString& aTarget, const nsAString& aData)
+ : txOutputTransaction(ePITransaction), mTarget(aTarget), mData(aData) {
+ MOZ_COUNT_CTOR_INHERITED(txPITransaction, txOutputTransaction);
+ }
+ virtual ~txPITransaction() {
+ MOZ_COUNT_DTOR_INHERITED(txPITransaction, txOutputTransaction);
+ }
+ nsString mTarget;
+ nsString mData;
+};
+
+class txStartElementAtomTransaction : public txOutputTransaction {
+ public:
+ txStartElementAtomTransaction(nsAtom* aPrefix, nsAtom* aLocalName,
+ nsAtom* aLowercaseLocalName, int32_t aNsID)
+ : txOutputTransaction(eStartElementAtomTransaction),
+ mPrefix(aPrefix),
+ mLocalName(aLocalName),
+ mLowercaseLocalName(aLowercaseLocalName),
+ mNsID(aNsID) {
+ MOZ_COUNT_CTOR_INHERITED(txStartElementAtomTransaction,
+ txOutputTransaction);
+ }
+ virtual ~txStartElementAtomTransaction() {
+ MOZ_COUNT_DTOR_INHERITED(txStartElementAtomTransaction,
+ txOutputTransaction);
+ }
+ RefPtr<nsAtom> mPrefix;
+ RefPtr<nsAtom> mLocalName;
+ RefPtr<nsAtom> mLowercaseLocalName;
+ int32_t mNsID;
+};
+
+class txStartElementTransaction : public txOutputTransaction {
+ public:
+ txStartElementTransaction(nsAtom* aPrefix, const nsAString& aLocalName,
+ int32_t aNsID)
+ : txOutputTransaction(eStartElementTransaction),
+ mPrefix(aPrefix),
+ mLocalName(aLocalName),
+ mNsID(aNsID) {
+ MOZ_COUNT_CTOR_INHERITED(txStartElementTransaction, txOutputTransaction);
+ }
+ virtual ~txStartElementTransaction() {
+ MOZ_COUNT_DTOR_INHERITED(txStartElementTransaction, txOutputTransaction);
+ }
+ RefPtr<nsAtom> mPrefix;
+ nsString mLocalName;
+ int32_t mNsID;
+};
+
+class txAttributeTransaction : public txOutputTransaction {
+ public:
+ txAttributeTransaction(nsAtom* aPrefix, const nsAString& aLocalName,
+ int32_t aNsID, const nsString& aValue)
+ : txOutputTransaction(eAttributeTransaction),
+ mPrefix(aPrefix),
+ mLocalName(aLocalName),
+ mNsID(aNsID),
+ mValue(aValue) {
+ MOZ_COUNT_CTOR_INHERITED(txAttributeTransaction, txOutputTransaction);
+ }
+ virtual ~txAttributeTransaction() {
+ MOZ_COUNT_DTOR_INHERITED(txAttributeTransaction, txOutputTransaction);
+ }
+ RefPtr<nsAtom> mPrefix;
+ nsString mLocalName;
+ int32_t mNsID;
+ nsString mValue;
+};
+
+class txAttributeAtomTransaction : public txOutputTransaction {
+ public:
+ txAttributeAtomTransaction(nsAtom* aPrefix, nsAtom* aLocalName,
+ nsAtom* aLowercaseLocalName, int32_t aNsID,
+ const nsString& aValue)
+ : txOutputTransaction(eAttributeAtomTransaction),
+ mPrefix(aPrefix),
+ mLocalName(aLocalName),
+ mLowercaseLocalName(aLowercaseLocalName),
+ mNsID(aNsID),
+ mValue(aValue) {
+ MOZ_COUNT_CTOR_INHERITED(txAttributeAtomTransaction, txOutputTransaction);
+ }
+ virtual ~txAttributeAtomTransaction() {
+ MOZ_COUNT_DTOR_INHERITED(txAttributeAtomTransaction, txOutputTransaction);
+ }
+ RefPtr<nsAtom> mPrefix;
+ RefPtr<nsAtom> mLocalName;
+ RefPtr<nsAtom> mLowercaseLocalName;
+ int32_t mNsID;
+ nsString mValue;
+};
+
+txBufferingHandler::txBufferingHandler() : mCanAddAttribute(false) {
+ MOZ_COUNT_CTOR(txBufferingHandler);
+ mBuffer = MakeUnique<txResultBuffer>();
+}
+
+txBufferingHandler::~txBufferingHandler() {
+ MOZ_COUNT_DTOR(txBufferingHandler);
+}
+
+nsresult txBufferingHandler::attribute(nsAtom* aPrefix, nsAtom* aLocalName,
+ nsAtom* aLowercaseLocalName,
+ int32_t aNsID, const nsString& aValue) {
+ NS_ENSURE_TRUE(mBuffer, NS_ERROR_OUT_OF_MEMORY);
+
+ if (!mCanAddAttribute) {
+ // XXX ErrorReport: Can't add attributes without element
+ return NS_OK;
+ }
+
+ txOutputTransaction* transaction = new txAttributeAtomTransaction(
+ aPrefix, aLocalName, aLowercaseLocalName, aNsID, aValue);
+ return mBuffer->addTransaction(transaction);
+}
+
+nsresult txBufferingHandler::attribute(nsAtom* aPrefix,
+ const nsAString& aLocalName,
+ const int32_t aNsID,
+ const nsString& aValue) {
+ NS_ENSURE_TRUE(mBuffer, NS_ERROR_OUT_OF_MEMORY);
+
+ if (!mCanAddAttribute) {
+ // XXX ErrorReport: Can't add attributes without element
+ return NS_OK;
+ }
+
+ txOutputTransaction* transaction =
+ new txAttributeTransaction(aPrefix, aLocalName, aNsID, aValue);
+ return mBuffer->addTransaction(transaction);
+}
+
+nsresult txBufferingHandler::characters(const nsAString& aData, bool aDOE) {
+ NS_ENSURE_TRUE(mBuffer, NS_ERROR_OUT_OF_MEMORY);
+
+ mCanAddAttribute = false;
+
+ txOutputTransaction::txTransactionType type =
+ aDOE ? txOutputTransaction::eCharacterNoOETransaction
+ : txOutputTransaction::eCharacterTransaction;
+
+ txOutputTransaction* transaction = mBuffer->getLastTransaction();
+ if (transaction && transaction->mType == type) {
+ mBuffer->mStringValue.Append(aData);
+ static_cast<txCharacterTransaction*>(transaction)->mLength +=
+ aData.Length();
+ return NS_OK;
+ }
+
+ transaction = new txCharacterTransaction(type, aData.Length());
+ mBuffer->mStringValue.Append(aData);
+ return mBuffer->addTransaction(transaction);
+}
+
+nsresult txBufferingHandler::comment(const nsString& aData) {
+ NS_ENSURE_TRUE(mBuffer, NS_ERROR_OUT_OF_MEMORY);
+
+ mCanAddAttribute = false;
+
+ txOutputTransaction* transaction = new txCommentTransaction(aData);
+ return mBuffer->addTransaction(transaction);
+}
+
+nsresult txBufferingHandler::endDocument(nsresult aResult) {
+ NS_ENSURE_TRUE(mBuffer, NS_ERROR_OUT_OF_MEMORY);
+
+ txOutputTransaction* transaction =
+ new txOutputTransaction(txOutputTransaction::eEndDocumentTransaction);
+ return mBuffer->addTransaction(transaction);
+}
+
+nsresult txBufferingHandler::endElement() {
+ NS_ENSURE_TRUE(mBuffer, NS_ERROR_OUT_OF_MEMORY);
+
+ mCanAddAttribute = false;
+
+ txOutputTransaction* transaction =
+ new txOutputTransaction(txOutputTransaction::eEndElementTransaction);
+ return mBuffer->addTransaction(transaction);
+}
+
+nsresult txBufferingHandler::processingInstruction(const nsString& aTarget,
+ const nsString& aData) {
+ NS_ENSURE_TRUE(mBuffer, NS_ERROR_OUT_OF_MEMORY);
+
+ mCanAddAttribute = false;
+
+ txOutputTransaction* transaction = new txPITransaction(aTarget, aData);
+ return mBuffer->addTransaction(transaction);
+}
+
+nsresult txBufferingHandler::startDocument() {
+ NS_ENSURE_TRUE(mBuffer, NS_ERROR_OUT_OF_MEMORY);
+
+ txOutputTransaction* transaction =
+ new txOutputTransaction(txOutputTransaction::eStartDocumentTransaction);
+ return mBuffer->addTransaction(transaction);
+}
+
+nsresult txBufferingHandler::startElement(nsAtom* aPrefix, nsAtom* aLocalName,
+ nsAtom* aLowercaseLocalName,
+ int32_t aNsID) {
+ NS_ENSURE_TRUE(mBuffer, NS_ERROR_OUT_OF_MEMORY);
+
+ mCanAddAttribute = true;
+
+ txOutputTransaction* transaction = new txStartElementAtomTransaction(
+ aPrefix, aLocalName, aLowercaseLocalName, aNsID);
+ return mBuffer->addTransaction(transaction);
+}
+
+nsresult txBufferingHandler::startElement(nsAtom* aPrefix,
+ const nsAString& aLocalName,
+ const int32_t aNsID) {
+ NS_ENSURE_TRUE(mBuffer, NS_ERROR_OUT_OF_MEMORY);
+
+ mCanAddAttribute = true;
+
+ txOutputTransaction* transaction =
+ new txStartElementTransaction(aPrefix, aLocalName, aNsID);
+ return mBuffer->addTransaction(transaction);
+}
+
+txResultBuffer::txResultBuffer() { MOZ_COUNT_CTOR(txResultBuffer); }
+
+txResultBuffer::~txResultBuffer() {
+ MOZ_COUNT_DTOR(txResultBuffer);
+ for (uint32_t i = 0, len = mTransactions.Length(); i < len; ++i) {
+ delete mTransactions[i];
+ }
+}
+
+nsresult txResultBuffer::addTransaction(txOutputTransaction* aTransaction) {
+ // XXX(Bug 1631371) Check if this should use a fallible operation as it
+ // pretended earlier, or change the return type to void.
+ mTransactions.AppendElement(aTransaction);
+ return NS_OK;
+}
+
+static nsresult flushTransaction(txOutputTransaction* aTransaction,
+ txAXMLEventHandler* aHandler,
+ nsString::const_char_iterator& aIter) {
+ switch (aTransaction->mType) {
+ case txOutputTransaction::eAttributeAtomTransaction: {
+ txAttributeAtomTransaction* transaction =
+ static_cast<txAttributeAtomTransaction*>(aTransaction);
+ return aHandler->attribute(transaction->mPrefix, transaction->mLocalName,
+ transaction->mLowercaseLocalName,
+ transaction->mNsID, transaction->mValue);
+ }
+ case txOutputTransaction::eAttributeTransaction: {
+ txAttributeTransaction* attrTransaction =
+ static_cast<txAttributeTransaction*>(aTransaction);
+ return aHandler->attribute(
+ attrTransaction->mPrefix, attrTransaction->mLocalName,
+ attrTransaction->mNsID, attrTransaction->mValue);
+ }
+ case txOutputTransaction::eCharacterTransaction:
+ case txOutputTransaction::eCharacterNoOETransaction: {
+ txCharacterTransaction* charTransaction =
+ static_cast<txCharacterTransaction*>(aTransaction);
+ nsString::const_char_iterator start = aIter;
+ nsString::const_char_iterator end = start + charTransaction->mLength;
+ aIter = end;
+ return aHandler->characters(
+ Substring(start, end),
+ aTransaction->mType ==
+ txOutputTransaction::eCharacterNoOETransaction);
+ }
+ case txOutputTransaction::eCommentTransaction: {
+ txCommentTransaction* commentTransaction =
+ static_cast<txCommentTransaction*>(aTransaction);
+ return aHandler->comment(commentTransaction->mValue);
+ }
+ case txOutputTransaction::eEndElementTransaction: {
+ return aHandler->endElement();
+ }
+ case txOutputTransaction::ePITransaction: {
+ txPITransaction* piTransaction =
+ static_cast<txPITransaction*>(aTransaction);
+ return aHandler->processingInstruction(piTransaction->mTarget,
+ piTransaction->mData);
+ }
+ case txOutputTransaction::eStartDocumentTransaction: {
+ return aHandler->startDocument();
+ }
+ case txOutputTransaction::eStartElementAtomTransaction: {
+ txStartElementAtomTransaction* transaction =
+ static_cast<txStartElementAtomTransaction*>(aTransaction);
+ return aHandler->startElement(
+ transaction->mPrefix, transaction->mLocalName,
+ transaction->mLowercaseLocalName, transaction->mNsID);
+ }
+ case txOutputTransaction::eStartElementTransaction: {
+ txStartElementTransaction* transaction =
+ static_cast<txStartElementTransaction*>(aTransaction);
+ return aHandler->startElement(
+ transaction->mPrefix, transaction->mLocalName, transaction->mNsID);
+ }
+ default: {
+ MOZ_ASSERT_UNREACHABLE("Unexpected transaction type");
+ }
+ }
+
+ return NS_ERROR_UNEXPECTED;
+}
+
+nsresult txResultBuffer::flushToHandler(txAXMLEventHandler* aHandler) {
+ nsString::const_char_iterator iter;
+ mStringValue.BeginReading(iter);
+
+ for (uint32_t i = 0, len = mTransactions.Length(); i < len; ++i) {
+ nsresult rv = flushTransaction(mTransactions[i], aHandler, iter);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ return NS_OK;
+}
+
+txOutputTransaction* txResultBuffer::getLastTransaction() {
+ int32_t last = mTransactions.Length() - 1;
+ if (last < 0) {
+ return nullptr;
+ }
+ return mTransactions[last];
+}
diff --git a/dom/xslt/xslt/txBufferingHandler.h b/dom/xslt/xslt/txBufferingHandler.h
new file mode 100644
index 0000000000..5fc41f312c
--- /dev/null
+++ b/dom/xslt/xslt/txBufferingHandler.h
@@ -0,0 +1,45 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef txBufferingHandler_h__
+#define txBufferingHandler_h__
+
+#include "mozilla/UniquePtr.h"
+#include "txXMLEventHandler.h"
+#include "nsString.h"
+#include "nsTArray.h"
+
+class txOutputTransaction;
+
+class txResultBuffer {
+ public:
+ txResultBuffer();
+ ~txResultBuffer();
+
+ nsresult addTransaction(txOutputTransaction* aTransaction);
+
+ nsresult flushToHandler(txAXMLEventHandler* aHandler);
+
+ txOutputTransaction* getLastTransaction();
+
+ nsString mStringValue;
+
+ private:
+ nsTArray<txOutputTransaction*> mTransactions;
+};
+
+class txBufferingHandler : public txAXMLEventHandler {
+ public:
+ txBufferingHandler();
+ virtual ~txBufferingHandler();
+
+ TX_DECL_TXAXMLEVENTHANDLER
+
+ protected:
+ mozilla::UniquePtr<txResultBuffer> mBuffer;
+ bool mCanAddAttribute;
+};
+
+#endif /* txBufferingHandler_h__ */
diff --git a/dom/xslt/xslt/txCurrentFunctionCall.cpp b/dom/xslt/xslt/txCurrentFunctionCall.cpp
new file mode 100644
index 0000000000..bf44d8eadd
--- /dev/null
+++ b/dom/xslt/xslt/txCurrentFunctionCall.cpp
@@ -0,0 +1,50 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsGkAtoms.h"
+#include "txXSLTFunctions.h"
+#include "txExecutionState.h"
+
+/*
+ Implementation of XSLT 1.0 extension function: current
+*/
+
+/**
+ * Creates a new current function call
+ **/
+CurrentFunctionCall::CurrentFunctionCall() = default;
+
+/*
+ * Evaluates this Expr
+ *
+ * @return NodeSet containing the context node used for the complete
+ * Expr or Pattern.
+ */
+nsresult CurrentFunctionCall::evaluate(txIEvalContext* aContext,
+ txAExprResult** aResult) {
+ *aResult = nullptr;
+
+ if (!requireParams(0, 0, aContext)) return NS_ERROR_XPATH_BAD_ARGUMENT_COUNT;
+
+ txExecutionState* es =
+ static_cast<txExecutionState*>(aContext->getPrivateContext());
+ if (!es) {
+ NS_ERROR("called xslt extension function \"current\" with wrong context");
+ return NS_ERROR_UNEXPECTED;
+ }
+ return aContext->recycler()->getNodeSet(
+ es->getEvalContext()->getContextNode(), aResult);
+}
+
+Expr::ResultType CurrentFunctionCall::getReturnType() { return NODESET_RESULT; }
+
+bool CurrentFunctionCall::isSensitiveTo(ContextSensitivity aContext) {
+ return !!(aContext & PRIVATE_CONTEXT);
+}
+
+#ifdef TX_TO_STRING
+void CurrentFunctionCall::appendName(nsAString& aDest) {
+ aDest.Append(nsGkAtoms::current->GetUTF16String());
+}
+#endif
diff --git a/dom/xslt/xslt/txDocumentFunctionCall.cpp b/dom/xslt/xslt/txDocumentFunctionCall.cpp
new file mode 100644
index 0000000000..94d7f04035
--- /dev/null
+++ b/dom/xslt/xslt/txDocumentFunctionCall.cpp
@@ -0,0 +1,150 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+ * DocumentFunctionCall
+ * A representation of the XSLT additional function: document()
+ */
+
+#include "nsGkAtoms.h"
+#include "txIXPathContext.h"
+#include "txXSLTFunctions.h"
+#include "txExecutionState.h"
+#include "txURIUtils.h"
+
+/*
+ * Creates a new DocumentFunctionCall.
+ */
+DocumentFunctionCall::DocumentFunctionCall(const nsAString& aBaseURI)
+ : mBaseURI(aBaseURI) {}
+
+static void retrieveNode(txExecutionState* aExecutionState,
+ const nsAString& aUri, const nsAString& aBaseUri,
+ txNodeSet* aNodeSet) {
+ nsAutoString absUrl;
+ URIUtils::resolveHref(aUri, aBaseUri, absUrl);
+
+ int32_t hash = absUrl.RFindChar(char16_t('#'));
+ uint32_t urlEnd, fragStart, fragEnd;
+ if (hash == kNotFound) {
+ urlEnd = absUrl.Length();
+ fragStart = 0;
+ fragEnd = 0;
+ } else {
+ urlEnd = hash;
+ fragStart = hash + 1;
+ fragEnd = absUrl.Length();
+ }
+
+ nsDependentSubstring docUrl(absUrl, 0, urlEnd);
+ nsDependentSubstring frag(absUrl, fragStart, fragEnd);
+
+ const txXPathNode* loadNode = aExecutionState->retrieveDocument(docUrl);
+ if (loadNode) {
+ if (frag.IsEmpty()) {
+ aNodeSet->add(*loadNode);
+ } else {
+ txXPathTreeWalker walker(*loadNode);
+ if (walker.moveToElementById(frag)) {
+ aNodeSet->add(walker.getCurrentPosition());
+ }
+ }
+ }
+}
+
+/*
+ * 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 = nullptr;
+ txExecutionState* es =
+ static_cast<txExecutionState*>(aContext->getPrivateContext());
+
+ RefPtr<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;
+ }
+
+ RefPtr<txAExprResult> exprResult1;
+ rv = mParams[0]->evaluate(aContext, getter_AddRefs(exprResult1));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ nsAutoString baseURI;
+ bool baseURISet = false;
+
+ if (mParams.Length() == 2) {
+ // We have 2 arguments, get baseURI from the first node
+ // in the resulting nodeset
+ RefPtr<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 = true;
+
+ if (!nodeSet2->isEmpty()) {
+ rv = txXPathNodeUtils::getBaseURI(nodeSet2->get(0), baseURI);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ }
+
+ if (exprResult1->getResultType() == txAExprResult::NODESET) {
+ // The first argument is a NodeSet, iterate on its nodes
+ txNodeSet* nodeSet1 =
+ static_cast<txNodeSet*>(static_cast<txAExprResult*>(exprResult1));
+ int32_t 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
+ rv = txXPathNodeUtils::getBaseURI(node, baseURI);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ 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;
+}
+
+Expr::ResultType DocumentFunctionCall::getReturnType() {
+ return NODESET_RESULT;
+}
+
+bool DocumentFunctionCall::isSensitiveTo(ContextSensitivity aContext) {
+ return (aContext & PRIVATE_CONTEXT) || argsSensitiveTo(aContext);
+}
+
+#ifdef TX_TO_STRING
+void DocumentFunctionCall::appendName(nsAString& aDest) {
+ aDest.Append(nsGkAtoms::document->GetUTF16String());
+}
+#endif
diff --git a/dom/xslt/xslt/txEXSLTFunctions.cpp b/dom/xslt/xslt/txEXSLTFunctions.cpp
new file mode 100644
index 0000000000..d4882d0b13
--- /dev/null
+++ b/dom/xslt/xslt/txEXSLTFunctions.cpp
@@ -0,0 +1,818 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/EnumeratedArray.h"
+#include "mozilla/EnumeratedRange.h"
+#include "mozilla/FloatingPoint.h"
+#include "mozilla/MacroArgs.h"
+#include "mozilla/MacroForEach.h"
+
+#include "nsAtom.h"
+#include "nsGkAtoms.h"
+#include "txExecutionState.h"
+#include "txExpr.h"
+#include "txIXPathContext.h"
+#include "txIEXSLTFunctions.h"
+#include "txNodeSet.h"
+#include "txOutputFormat.h"
+#include "txRtfHandler.h"
+#include "txXPathTreeWalker.h"
+#include "nsImportModule.h"
+#include "nsPrintfCString.h"
+#include "nsComponentManagerUtils.h"
+#include "nsContentCID.h"
+#include "nsContentCreatorFunctions.h"
+#include "nsIContent.h"
+#include "txMozillaXMLOutput.h"
+#include "nsTextNode.h"
+#include "mozilla/dom/DocumentFragmentBinding.h"
+#include "prtime.h"
+#include "xpcprivate.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+class txStylesheetCompilerState;
+
+// ------------------------------------------------------------------
+// Utility functions
+// ------------------------------------------------------------------
+
+static Document* getSourceDocument(txIEvalContext* aContext) {
+ txExecutionState* es =
+ static_cast<txExecutionState*>(aContext->getPrivateContext());
+ if (!es) {
+ NS_ERROR("Need txExecutionState!");
+
+ return nullptr;
+ }
+
+ const txXPathNode& document = es->getSourceDocument();
+ return txXPathNativeNode::getDocument(document);
+}
+
+static nsresult convertRtfToNode(txIEvalContext* aContext,
+ txResultTreeFragment* aRtf) {
+ Document* doc = getSourceDocument(aContext);
+ if (!doc) {
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ RefPtr<DocumentFragment> domFragment =
+ new (doc->NodeInfoManager()) DocumentFragment(doc->NodeInfoManager());
+
+ txOutputFormat format;
+ txMozillaXMLOutput mozHandler(&format, domFragment, true);
+
+ nsresult rv = aRtf->flushToHandler(&mozHandler);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = mozHandler.closePrevious(true);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // The txResultTreeFragment will own this.
+ const txXPathNode* node =
+ txXPathNativeNode::createXPathNode(domFragment, true);
+ NS_ENSURE_TRUE(node, NS_ERROR_OUT_OF_MEMORY);
+
+ aRtf->setNode(node);
+
+ return NS_OK;
+}
+
+static nsresult createTextNode(txIEvalContext* aContext, nsString& aValue,
+ txXPathNode** aResult) {
+ Document* doc = getSourceDocument(aContext);
+ if (!doc) {
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ RefPtr<nsTextNode> text =
+ new (doc->NodeInfoManager()) nsTextNode(doc->NodeInfoManager());
+
+ nsresult rv = text->SetText(aValue, false);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ *aResult = txXPathNativeNode::createXPathNode(text, true);
+ NS_ENSURE_TRUE(*aResult, NS_ERROR_OUT_OF_MEMORY);
+
+ return NS_OK;
+}
+
+static nsresult createAndAddToResult(nsAtom* aName, const nsAString& aValue,
+ txNodeSet* aResultSet,
+ DocumentFragment* aResultHolder) {
+ Document* doc = aResultHolder->OwnerDoc();
+ nsCOMPtr<Element> elem =
+ doc->CreateElem(nsDependentAtomString(aName), nullptr, kNameSpaceID_None);
+ NS_ENSURE_TRUE(elem, NS_ERROR_NULL_POINTER);
+
+ RefPtr<nsTextNode> text =
+ new (doc->NodeInfoManager()) nsTextNode(doc->NodeInfoManager());
+
+ nsresult rv = text->SetText(aValue, false);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ ErrorResult error;
+ elem->AppendChildTo(text, false, error);
+ if (error.Failed()) {
+ return error.StealNSResult();
+ }
+
+ aResultHolder->AppendChildTo(elem, false, error);
+ if (error.Failed()) {
+ return error.StealNSResult();
+ }
+
+ UniquePtr<txXPathNode> xpathNode(
+ txXPathNativeNode::createXPathNode(elem, true));
+ NS_ENSURE_TRUE(xpathNode, NS_ERROR_OUT_OF_MEMORY);
+
+ aResultSet->append(*xpathNode);
+
+ return NS_OK;
+}
+
+// Need to update this array if types are added to the ResultType enum in
+// txAExprResult.
+static const char* const sTypes[] = {"node-set", "boolean", "number", "string",
+ "RTF"};
+
+// ------------------------------------------------------------------
+// Function implementations
+// ------------------------------------------------------------------
+
+enum class txEXSLTType {
+ // http://exslt.org/common
+ NODE_SET,
+ OBJECT_TYPE,
+
+ // http://exslt.org/dates-and-times
+ DATE_TIME,
+
+ // http://exslt.org/math
+ MAX,
+ MIN,
+ HIGHEST,
+ LOWEST,
+
+ // http://exslt.org/regular-expressions
+ MATCH,
+ REPLACE,
+ TEST,
+
+ // http://exslt.org/sets
+ DIFFERENCE_, // not DIFFERENCE to avoid a conflict with a winuser.h macro
+ DISTINCT,
+ HAS_SAME_NODE,
+ INTERSECTION,
+ LEADING,
+ TRAILING,
+
+ // http://exslt.org/strings
+ CONCAT,
+ SPLIT,
+ TOKENIZE,
+
+ _LIMIT,
+};
+
+struct txEXSLTFunctionDescriptor {
+ int8_t mMinParams;
+ int8_t mMaxParams;
+ Expr::ResultType mReturnType;
+ nsStaticAtom* mName;
+ bool (*mCreator)(txEXSLTType, FunctionCall**);
+ int32_t mNamespaceID;
+};
+
+static EnumeratedArray<txEXSLTType, txEXSLTType::_LIMIT,
+ txEXSLTFunctionDescriptor>
+ descriptTable;
+
+class txEXSLTFunctionCall : public FunctionCall {
+ public:
+ explicit txEXSLTFunctionCall(txEXSLTType aType) : mType(aType) {}
+
+ static bool Create(txEXSLTType aType, FunctionCall** aFunction) {
+ *aFunction = new txEXSLTFunctionCall(aType);
+ return true;
+ }
+
+ TX_DECL_FUNCTION
+
+ private:
+ txEXSLTType mType;
+};
+
+class txEXSLTRegExFunctionCall : public FunctionCall {
+ public:
+ explicit txEXSLTRegExFunctionCall(txEXSLTType aType) : mType(aType) {}
+
+ static bool Create(txEXSLTType aType, FunctionCall** aFunction) {
+ *aFunction = new txEXSLTRegExFunctionCall(aType);
+ return true;
+ }
+
+ TX_DECL_FUNCTION
+
+ private:
+ txEXSLTType mType;
+};
+
+nsresult txEXSLTFunctionCall::evaluate(txIEvalContext* aContext,
+ txAExprResult** aResult) {
+ *aResult = nullptr;
+ if (!requireParams(descriptTable[mType].mMinParams,
+ descriptTable[mType].mMaxParams, aContext)) {
+ return NS_ERROR_XPATH_BAD_ARGUMENT_COUNT;
+ }
+
+ nsresult rv = NS_OK;
+ switch (mType) {
+ case txEXSLTType::NODE_SET: {
+ RefPtr<txAExprResult> exprResult;
+ rv = mParams[0]->evaluate(aContext, getter_AddRefs(exprResult));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (exprResult->getResultType() == txAExprResult::NODESET) {
+ exprResult.forget(aResult);
+ } else {
+ RefPtr<txNodeSet> resultSet;
+ rv = aContext->recycler()->getNodeSet(getter_AddRefs(resultSet));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (exprResult->getResultType() ==
+ txAExprResult::RESULT_TREE_FRAGMENT) {
+ txResultTreeFragment* rtf =
+ static_cast<txResultTreeFragment*>(exprResult.get());
+
+ const txXPathNode* node = rtf->getNode();
+ if (!node) {
+ rv = convertRtfToNode(aContext, rtf);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ node = rtf->getNode();
+ }
+
+ resultSet->append(*node);
+ } else {
+ nsAutoString value;
+ exprResult->stringValue(value);
+
+ UniquePtr<txXPathNode> node;
+ rv = createTextNode(aContext, value, getter_Transfers(node));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ resultSet->append(*node);
+ }
+
+ NS_ADDREF(*aResult = resultSet);
+ }
+
+ return NS_OK;
+ }
+ case txEXSLTType::OBJECT_TYPE: {
+ RefPtr<txAExprResult> exprResult;
+ nsresult rv = mParams[0]->evaluate(aContext, getter_AddRefs(exprResult));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ RefPtr<StringResult> strRes;
+ rv = aContext->recycler()->getStringResult(getter_AddRefs(strRes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ AppendASCIItoUTF16(MakeStringSpan(sTypes[exprResult->getResultType()]),
+ strRes->mValue);
+
+ NS_ADDREF(*aResult = strRes);
+
+ return NS_OK;
+ }
+ case txEXSLTType::DIFFERENCE_:
+ case txEXSLTType::INTERSECTION: {
+ RefPtr<txNodeSet> nodes1;
+ rv = evaluateToNodeSet(mParams[0], aContext, getter_AddRefs(nodes1));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ RefPtr<txNodeSet> nodes2;
+ rv = evaluateToNodeSet(mParams[1], aContext, getter_AddRefs(nodes2));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ RefPtr<txNodeSet> resultSet;
+ rv = aContext->recycler()->getNodeSet(getter_AddRefs(resultSet));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ bool insertOnFound = mType == txEXSLTType::INTERSECTION;
+
+ int32_t searchPos = 0;
+ int32_t i, len = nodes1->size();
+ for (i = 0; i < len; ++i) {
+ const txXPathNode& node = nodes1->get(i);
+ int32_t foundPos = nodes2->indexOf(node, searchPos);
+ if (foundPos >= 0) {
+ searchPos = foundPos + 1;
+ }
+
+ if ((foundPos >= 0) == insertOnFound) {
+ rv = resultSet->append(node);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ }
+
+ NS_ADDREF(*aResult = resultSet);
+
+ return NS_OK;
+ }
+ case txEXSLTType::DISTINCT: {
+ RefPtr<txNodeSet> nodes;
+ rv = evaluateToNodeSet(mParams[0], aContext, getter_AddRefs(nodes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ RefPtr<txNodeSet> resultSet;
+ rv = aContext->recycler()->getNodeSet(getter_AddRefs(resultSet));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ nsTHashSet<nsString> hash;
+
+ int32_t i, len = nodes->size();
+ for (i = 0; i < len; ++i) {
+ nsAutoString str;
+ const txXPathNode& node = nodes->get(i);
+ txXPathNodeUtils::appendNodeValue(node, str);
+ if (hash.EnsureInserted(str)) {
+ rv = resultSet->append(node);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ }
+
+ NS_ADDREF(*aResult = resultSet);
+
+ return NS_OK;
+ }
+ case txEXSLTType::HAS_SAME_NODE: {
+ RefPtr<txNodeSet> nodes1;
+ rv = evaluateToNodeSet(mParams[0], aContext, getter_AddRefs(nodes1));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ RefPtr<txNodeSet> nodes2;
+ rv = evaluateToNodeSet(mParams[1], aContext, getter_AddRefs(nodes2));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ bool found = false;
+ int32_t i, len = nodes1->size();
+ for (i = 0; i < len; ++i) {
+ if (nodes2->contains(nodes1->get(i))) {
+ found = true;
+ break;
+ }
+ }
+
+ aContext->recycler()->getBoolResult(found, aResult);
+
+ return NS_OK;
+ }
+ case txEXSLTType::LEADING:
+ case txEXSLTType::TRAILING: {
+ RefPtr<txNodeSet> nodes1;
+ rv = evaluateToNodeSet(mParams[0], aContext, getter_AddRefs(nodes1));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ RefPtr<txNodeSet> nodes2;
+ rv = evaluateToNodeSet(mParams[1], aContext, getter_AddRefs(nodes2));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (nodes2->isEmpty()) {
+ *aResult = nodes1;
+ NS_ADDREF(*aResult);
+
+ return NS_OK;
+ }
+
+ RefPtr<txNodeSet> resultSet;
+ rv = aContext->recycler()->getNodeSet(getter_AddRefs(resultSet));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ int32_t end = nodes1->indexOf(nodes2->get(0));
+ if (end >= 0) {
+ int32_t i = 0;
+ if (mType == txEXSLTType::TRAILING) {
+ i = end + 1;
+ end = nodes1->size();
+ }
+ for (; i < end; ++i) {
+ rv = resultSet->append(nodes1->get(i));
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ }
+
+ NS_ADDREF(*aResult = resultSet);
+
+ return NS_OK;
+ }
+ case txEXSLTType::CONCAT: {
+ RefPtr<txNodeSet> nodes;
+ rv = evaluateToNodeSet(mParams[0], aContext, getter_AddRefs(nodes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ nsAutoString str;
+ int32_t i, len = nodes->size();
+ for (i = 0; i < len; ++i) {
+ txXPathNodeUtils::appendNodeValue(nodes->get(i), str);
+ }
+
+ return aContext->recycler()->getStringResult(str, aResult);
+ }
+ case txEXSLTType::SPLIT:
+ case txEXSLTType::TOKENIZE: {
+ // Evaluate parameters
+ nsAutoString string;
+ rv = mParams[0]->evaluateToString(aContext, string);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ nsAutoString pattern;
+ if (mParams.Length() == 2) {
+ rv = mParams[1]->evaluateToString(aContext, pattern);
+ NS_ENSURE_SUCCESS(rv, rv);
+ } else if (mType == txEXSLTType::SPLIT) {
+ pattern.Assign(' ');
+ } else {
+ pattern.AssignLiteral("\t\r\n ");
+ }
+
+ // Set up holders for the result
+ Document* sourceDoc = getSourceDocument(aContext);
+ NS_ENSURE_STATE(sourceDoc);
+
+ RefPtr<DocumentFragment> docFrag = new (sourceDoc->NodeInfoManager())
+ DocumentFragment(sourceDoc->NodeInfoManager());
+
+ RefPtr<txNodeSet> resultSet;
+ rv = aContext->recycler()->getNodeSet(getter_AddRefs(resultSet));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ uint32_t tailIndex;
+
+ // Start splitting
+ if (pattern.IsEmpty()) {
+ nsString::const_char_iterator start = string.BeginReading();
+ nsString::const_char_iterator end = string.EndReading();
+ for (; start < end; ++start) {
+ rv = createAndAddToResult(nsGkAtoms::token,
+ Substring(start, start + 1), resultSet,
+ docFrag);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ tailIndex = string.Length();
+ } else if (mType == txEXSLTType::SPLIT) {
+ nsAString::const_iterator strStart, strEnd;
+ string.BeginReading(strStart);
+ string.EndReading(strEnd);
+ nsAString::const_iterator start = strStart, end = strEnd;
+
+ while (FindInReadable(pattern, start, end)) {
+ if (start != strStart) {
+ rv = createAndAddToResult(nsGkAtoms::token,
+ Substring(strStart, start), resultSet,
+ docFrag);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ strStart = start = end;
+ end = strEnd;
+ }
+
+ tailIndex = strStart.get() - string.get();
+ } else {
+ int32_t found, start = 0;
+ while ((found = string.FindCharInSet(pattern, start)) != kNotFound) {
+ if (found != start) {
+ rv = createAndAddToResult(nsGkAtoms::token,
+ Substring(string, start, found - start),
+ resultSet, docFrag);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ start = found + 1;
+ }
+
+ tailIndex = start;
+ }
+
+ // Add tail if needed
+ if (tailIndex != (uint32_t)string.Length()) {
+ rv = createAndAddToResult(
+ nsGkAtoms::token, Substring(string, tailIndex), resultSet, docFrag);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ NS_ADDREF(*aResult = resultSet);
+
+ return NS_OK;
+ }
+ case txEXSLTType::MAX:
+ case txEXSLTType::MIN: {
+ RefPtr<txNodeSet> nodes;
+ rv = evaluateToNodeSet(mParams[0], aContext, getter_AddRefs(nodes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (nodes->isEmpty()) {
+ return aContext->recycler()->getNumberResult(UnspecifiedNaN<double>(),
+ aResult);
+ }
+
+ bool findMax = mType == txEXSLTType::MAX;
+
+ double res = findMax ? mozilla::NegativeInfinity<double>()
+ : mozilla::PositiveInfinity<double>();
+ int32_t i, len = nodes->size();
+ for (i = 0; i < len; ++i) {
+ nsAutoString str;
+ txXPathNodeUtils::appendNodeValue(nodes->get(i), str);
+ double val = txDouble::toDouble(str);
+ if (std::isnan(val)) {
+ res = UnspecifiedNaN<double>();
+ break;
+ }
+
+ if (findMax ? (val > res) : (val < res)) {
+ res = val;
+ }
+ }
+
+ return aContext->recycler()->getNumberResult(res, aResult);
+ }
+ case txEXSLTType::HIGHEST:
+ case txEXSLTType::LOWEST: {
+ RefPtr<txNodeSet> nodes;
+ rv = evaluateToNodeSet(mParams[0], aContext, getter_AddRefs(nodes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (nodes->isEmpty()) {
+ NS_ADDREF(*aResult = nodes);
+
+ return NS_OK;
+ }
+
+ RefPtr<txNodeSet> resultSet;
+ rv = aContext->recycler()->getNodeSet(getter_AddRefs(resultSet));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ bool findMax = mType == txEXSLTType::HIGHEST;
+ double res = findMax ? mozilla::NegativeInfinity<double>()
+ : mozilla::PositiveInfinity<double>();
+ int32_t i, len = nodes->size();
+ for (i = 0; i < len; ++i) {
+ nsAutoString str;
+ const txXPathNode& node = nodes->get(i);
+ txXPathNodeUtils::appendNodeValue(node, str);
+ double val = txDouble::toDouble(str);
+ if (std::isnan(val)) {
+ resultSet->clear();
+ break;
+ }
+ if (findMax ? (val > res) : (val < res)) {
+ resultSet->clear();
+ res = val;
+ }
+
+ if (res == val) {
+ rv = resultSet->append(node);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ }
+
+ NS_ADDREF(*aResult = resultSet);
+
+ return NS_OK;
+ }
+ case txEXSLTType::DATE_TIME: {
+ // http://exslt.org/date/functions/date-time/
+
+ PRExplodedTime prtime;
+ PR_ExplodeTime(PR_Now(), PR_LocalTimeParameters, &prtime);
+
+ int32_t offset =
+ (prtime.tm_params.tp_gmt_offset + prtime.tm_params.tp_dst_offset) /
+ 60;
+
+ bool isneg = offset < 0;
+ if (isneg) offset = -offset;
+
+ StringResult* strRes;
+ rv = aContext->recycler()->getStringResult(&strRes);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // format: YYYY-MM-DDTTHH:MM:SS.sss+00:00
+ CopyASCIItoUTF16(
+ nsPrintfCString("%04hd-%02" PRId32 "-%02" PRId32 "T%02" PRId32
+ ":%02" PRId32 ":%02" PRId32 ".%03" PRId32
+ "%c%02" PRId32 ":%02" PRId32,
+ prtime.tm_year, prtime.tm_month + 1, prtime.tm_mday,
+ prtime.tm_hour, prtime.tm_min, prtime.tm_sec,
+ prtime.tm_usec / 10000, isneg ? '-' : '+',
+ offset / 60, offset % 60),
+ strRes->mValue);
+
+ *aResult = strRes;
+
+ return NS_OK;
+ }
+ default: {
+ aContext->receiveError(u"Internal error"_ns, NS_ERROR_UNEXPECTED);
+ return NS_ERROR_UNEXPECTED;
+ }
+ }
+
+ MOZ_ASSERT_UNREACHABLE("Missing return?");
+ return NS_ERROR_UNEXPECTED;
+}
+
+Expr::ResultType txEXSLTFunctionCall::getReturnType() {
+ return descriptTable[mType].mReturnType;
+}
+
+bool txEXSLTFunctionCall::isSensitiveTo(ContextSensitivity aContext) {
+ if (mType == txEXSLTType::NODE_SET || mType == txEXSLTType::SPLIT ||
+ mType == txEXSLTType::TOKENIZE) {
+ return (aContext & PRIVATE_CONTEXT) || argsSensitiveTo(aContext);
+ }
+ return argsSensitiveTo(aContext);
+}
+
+#ifdef TX_TO_STRING
+void txEXSLTFunctionCall::appendName(nsAString& aDest) {
+ aDest.Append(descriptTable[mType].mName->GetUTF16String());
+}
+#endif
+
+nsresult txEXSLTRegExFunctionCall::evaluate(txIEvalContext* aContext,
+ txAExprResult** aResult) {
+ *aResult = nullptr;
+ if (!requireParams(descriptTable[mType].mMinParams,
+ descriptTable[mType].mMaxParams, aContext)) {
+ return NS_ERROR_XPATH_BAD_ARGUMENT_COUNT;
+ }
+
+ nsAutoString string;
+ nsresult rv = mParams[0]->evaluateToString(aContext, string);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ nsAutoString regex;
+ rv = mParams[1]->evaluateToString(aContext, regex);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ nsAutoString flags;
+ if (mParams.Length() >= 3) {
+ rv = mParams[2]->evaluateToString(aContext, flags);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ nsCOMPtr<txIEXSLTFunctions> funcs =
+ do_ImportESModule("resource://gre/modules/txEXSLTRegExFunctions.sys.mjs");
+ MOZ_ALWAYS_TRUE(funcs);
+
+ switch (mType) {
+ case txEXSLTType::MATCH: {
+ nsCOMPtr<Document> sourceDoc = getSourceDocument(aContext);
+ NS_ENSURE_STATE(sourceDoc);
+
+ RefPtr<DocumentFragment> docFrag;
+ rv = funcs->Match(string, regex, flags, sourceDoc,
+ getter_AddRefs(docFrag));
+ NS_ENSURE_SUCCESS(rv, rv);
+ NS_ENSURE_STATE(docFrag);
+
+ RefPtr<txNodeSet> resultSet;
+ rv = aContext->recycler()->getNodeSet(getter_AddRefs(resultSet));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ UniquePtr<txXPathNode> node;
+ for (nsIContent* result = docFrag->GetFirstChild(); result;
+ result = result->GetNextSibling()) {
+ node = WrapUnique(txXPathNativeNode::createXPathNode(result, true));
+ rv = resultSet->add(*node);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ resultSet.forget(aResult);
+
+ return NS_OK;
+ }
+ case txEXSLTType::REPLACE: {
+ nsAutoString replace;
+ rv = mParams[3]->evaluateToString(aContext, replace);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ nsAutoString result;
+ rv = funcs->Replace(string, regex, flags, replace, result);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = aContext->recycler()->getStringResult(result, aResult);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ return NS_OK;
+ }
+ case txEXSLTType::TEST: {
+ bool result;
+ rv = funcs->Test(string, regex, flags, &result);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aContext->recycler()->getBoolResult(result, aResult);
+
+ return NS_OK;
+ }
+ default: {
+ aContext->receiveError(u"Internal error"_ns, NS_ERROR_UNEXPECTED);
+ return NS_ERROR_UNEXPECTED;
+ }
+ }
+
+ MOZ_ASSERT_UNREACHABLE("Missing return?");
+ return NS_ERROR_UNEXPECTED;
+}
+
+Expr::ResultType txEXSLTRegExFunctionCall::getReturnType() {
+ return descriptTable[mType].mReturnType;
+}
+
+bool txEXSLTRegExFunctionCall::isSensitiveTo(ContextSensitivity aContext) {
+ if (mType == txEXSLTType::MATCH) {
+ return (aContext & PRIVATE_CONTEXT) || argsSensitiveTo(aContext);
+ }
+ return argsSensitiveTo(aContext);
+}
+
+#ifdef TX_TO_STRING
+void txEXSLTRegExFunctionCall::appendName(nsAString& aDest) {
+ aDest.Append(descriptTable[mType].mName->GetUTF16String());
+}
+#endif
+
+extern nsresult TX_ConstructEXSLTFunction(nsAtom* aName, int32_t aNamespaceID,
+ txStylesheetCompilerState* aState,
+ FunctionCall** aResult) {
+ for (auto i : MakeEnumeratedRange(txEXSLTType::_LIMIT)) {
+ const txEXSLTFunctionDescriptor& desc = descriptTable[i];
+ if (aName == desc.mName && aNamespaceID == desc.mNamespaceID) {
+ return desc.mCreator(i, aResult) ? NS_OK : NS_ERROR_FAILURE;
+ }
+ }
+
+ return NS_ERROR_XPATH_UNKNOWN_FUNCTION;
+}
+
+extern bool TX_InitEXSLTFunction() {
+#define EXSLT_FUNCS(NS, CLASS, ...) \
+ { \
+ int32_t nsid = txNamespaceManager::getNamespaceID(nsLiteralString(NS)); \
+ if (nsid == kNameSpaceID_Unknown) { \
+ return false; \
+ } \
+ MOZ_FOR_EACH(EXSLT_FUNC, (nsid, CLASS, ), (__VA_ARGS__)) \
+ }
+
+#define EXSLT_FUNC(NS, CLASS, ...) \
+ descriptTable[txEXSLTType::MOZ_ARG_1 __VA_ARGS__] = { \
+ MOZ_ARGS_AFTER_1 __VA_ARGS__, CLASS::Create, NS};
+
+ EXSLT_FUNCS(u"http://exslt.org/common", txEXSLTFunctionCall,
+ (NODE_SET, 1, 1, Expr::NODESET_RESULT, nsGkAtoms::nodeSet),
+ (OBJECT_TYPE, 1, 1, Expr::STRING_RESULT, nsGkAtoms::objectType))
+
+ EXSLT_FUNCS(u"http://exslt.org/dates-and-times", txEXSLTFunctionCall,
+ (DATE_TIME, 0, 0, Expr::STRING_RESULT, nsGkAtoms::dateTime))
+
+ EXSLT_FUNCS(u"http://exslt.org/math", txEXSLTFunctionCall,
+ (MAX, 1, 1, Expr::NUMBER_RESULT, nsGkAtoms::max),
+ (MIN, 1, 1, Expr::NUMBER_RESULT, nsGkAtoms::min),
+ (HIGHEST, 1, 1, Expr::NODESET_RESULT, nsGkAtoms::highest),
+ (LOWEST, 1, 1, Expr::NODESET_RESULT, nsGkAtoms::lowest))
+
+ EXSLT_FUNCS(u"http://exslt.org/regular-expressions", txEXSLTRegExFunctionCall,
+ (MATCH, 2, 3, Expr::NODESET_RESULT, nsGkAtoms::match),
+ (REPLACE, 4, 4, Expr::STRING_RESULT, nsGkAtoms::replace),
+ (TEST, 2, 3, Expr::BOOLEAN_RESULT, nsGkAtoms::test))
+
+ EXSLT_FUNCS(
+ u"http://exslt.org/sets", txEXSLTFunctionCall,
+ (DIFFERENCE_, 2, 2, Expr::NODESET_RESULT, nsGkAtoms::difference),
+ (DISTINCT, 1, 1, Expr::NODESET_RESULT, nsGkAtoms::distinct),
+ (HAS_SAME_NODE, 2, 2, Expr::BOOLEAN_RESULT, nsGkAtoms::hasSameNode),
+ (INTERSECTION, 2, 2, Expr::NODESET_RESULT, nsGkAtoms::intersection),
+ (LEADING, 2, 2, Expr::NODESET_RESULT, nsGkAtoms::leading),
+ (TRAILING, 2, 2, Expr::NODESET_RESULT, nsGkAtoms::trailing))
+
+ EXSLT_FUNCS(u"http://exslt.org/strings", txEXSLTFunctionCall,
+ (CONCAT, 1, 1, Expr::STRING_RESULT, nsGkAtoms::concat),
+ (SPLIT, 1, 2, Expr::STRING_RESULT, nsGkAtoms::split),
+ (TOKENIZE, 1, 2, Expr::STRING_RESULT, nsGkAtoms::tokenize))
+
+#undef EXSLT_FUNCS
+#undef EXSLT_FUNC
+#undef EXSLT_FUNC_HELPER
+#undef EXSLT_FUNC_HELPER2
+
+ return true;
+}
diff --git a/dom/xslt/xslt/txEXSLTRegExFunctions.sys.mjs b/dom/xslt/xslt/txEXSLTRegExFunctions.sys.mjs
new file mode 100644
index 0000000000..d13ea6bea5
--- /dev/null
+++ b/dom/xslt/xslt/txEXSLTRegExFunctions.sys.mjs
@@ -0,0 +1,32 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+export function match(str, regex, flags, doc) {
+ var docFrag = doc.createDocumentFragment();
+ var re = new RegExp(regex, flags);
+ var matches = str.match(re);
+ if (matches != null) {
+ for (var i = 0; i < matches.length; ++i) {
+ var match = matches[i];
+ var elem = doc.createElementNS(null, "match");
+ var text = doc.createTextNode(match ? match : "");
+ elem.appendChild(text);
+ docFrag.appendChild(elem);
+ }
+ }
+ return docFrag;
+}
+
+export function replace(str, regex, flags, replace) {
+ var re = new RegExp(regex, flags);
+
+ return str.replace(re, replace);
+}
+
+export function test(str, regex, flags) {
+ var re = new RegExp(regex, flags);
+
+ return re.test(str);
+}
diff --git a/dom/xslt/xslt/txExecutionState.cpp b/dom/xslt/xslt/txExecutionState.cpp
new file mode 100644
index 0000000000..a3cfddac1c
--- /dev/null
+++ b/dom/xslt/xslt/txExecutionState.cpp
@@ -0,0 +1,460 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txExecutionState.h"
+#include "txSingleNodeContext.h"
+#include "txInstructions.h"
+#include "txStylesheet.h"
+#include "txVariableMap.h"
+#include "txRtfHandler.h"
+#include "txXSLTProcessor.h"
+#include "txLog.h"
+#include "txURIUtils.h"
+#include "txXMLParser.h"
+
+using mozilla::UniquePtr;
+using mozilla::Unused;
+using mozilla::WrapUnique;
+
+const int32_t txExecutionState::kMaxRecursionDepth = 20000;
+
+nsresult txLoadedDocumentsHash::init(const txXPathNode& aSource) {
+ mSourceDocument = WrapUnique(txXPathNodeUtils::getOwnerDocument(aSource));
+
+ nsAutoString baseURI;
+ nsresult rv = txXPathNodeUtils::getBaseURI(*mSourceDocument, baseURI);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+
+ // Technically the hash holds documents, but we allow any node that we're
+ // transforming from. In particular, the document() function uses this hash
+ // and it can return the source document, but if we're transforming from a
+ // document fragment (through
+ // txMozillaXSLTProcessor::SetSourceContentModel/txMozillaXSLTProcessor::DoTransform)
+ // or from another type of node (through
+ // txMozillaXSLTProcessor::TransformToDocument or
+ // txMozillaXSLTProcessor::TransformToFragment) it makes more sense to return
+ // the real root of the source tree, which is the node where the transform
+ // started.
+ PutEntry(baseURI)->mDocument = WrapUnique(
+ txXPathNativeNode::createXPathNode(txXPathNativeNode::getNode(aSource)));
+ return NS_OK;
+}
+
+txLoadedDocumentsHash::~txLoadedDocumentsHash() {
+ if (mSourceDocument) {
+ nsAutoString baseURI;
+ nsresult rv = txXPathNodeUtils::getBaseURI(*mSourceDocument, baseURI);
+ if (NS_SUCCEEDED(rv)) {
+ txLoadedDocumentEntry* entry = GetEntry(baseURI);
+ if (entry) {
+ delete entry->mDocument.release();
+ }
+ }
+ }
+}
+
+txExecutionState::txExecutionState(txStylesheet* aStylesheet,
+ bool aDisableLoads)
+ : mOutputHandler(nullptr),
+ mResultHandler(nullptr),
+ mOutputHandlerFactory(nullptr),
+ mStylesheet(aStylesheet),
+ mNextInstruction(nullptr),
+ mLocalVariables(nullptr),
+ mRecursionDepth(0),
+ mEvalContext(nullptr),
+ mInitialEvalContext(nullptr),
+ mGlobalParams(nullptr),
+ mKeyHash(aStylesheet->getKeyMap()),
+ mDisableLoads(aDisableLoads) {
+ MOZ_COUNT_CTOR(txExecutionState);
+}
+
+txExecutionState::~txExecutionState() {
+ MOZ_COUNT_DTOR(txExecutionState);
+
+ delete mResultHandler;
+ delete mLocalVariables;
+ if (mEvalContext != mInitialEvalContext) {
+ delete mEvalContext;
+ }
+
+ txStackIterator varsIter(&mLocalVarsStack);
+ while (varsIter.hasNext()) {
+ delete (txVariableMap*)varsIter.next();
+ }
+
+ txStackIterator contextIter(&mEvalContextStack);
+ while (contextIter.hasNext()) {
+ txIEvalContext* context = (txIEvalContext*)contextIter.next();
+ if (context != mInitialEvalContext) {
+ delete context;
+ }
+ }
+
+ txStackIterator handlerIter(&mResultHandlerStack);
+ while (handlerIter.hasNext()) {
+ delete (txAXMLEventHandler*)handlerIter.next();
+ }
+
+ delete mInitialEvalContext;
+}
+
+nsresult txExecutionState::init(
+ const txXPathNode& aNode,
+ txOwningExpandedNameMap<txIGlobalParameter>* aGlobalParams) {
+ nsresult rv = NS_OK;
+
+ mGlobalParams = aGlobalParams;
+
+ // Set up initial context
+ mEvalContext = new txSingleNodeContext(aNode, this);
+ mInitialEvalContext = mEvalContext;
+
+ // Set up output and result-handler
+ txAXMLEventHandler* handler;
+ rv = mOutputHandlerFactory->createHandlerWith(mStylesheet->getOutputFormat(),
+ &handler);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ mOutputHandler = handler;
+ mResultHandler = handler;
+ mOutputHandler->startDocument();
+
+ // Set up loaded-documents-hash
+ rv = mLoadedDocuments.init(aNode);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // Init members
+ rv = mKeyHash.init();
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ mRecycler = new txResultRecycler;
+
+ // The actual value here doesn't really matter since noone should use this
+ // value. But lets put something errorlike in just in case
+ mGlobalVarPlaceholderValue = new StringResult(u"Error"_ns, nullptr);
+
+ // Initiate first instruction. This has to be done last since findTemplate
+ // might use us.
+ txStylesheet::ImportFrame* frame = 0;
+ txExpandedName nullName;
+ txInstruction* templ;
+ rv =
+ mStylesheet->findTemplate(aNode, nullName, this, nullptr, &templ, &frame);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ pushTemplateRule(frame, nullName, nullptr);
+
+ return runTemplate(templ);
+}
+
+nsresult txExecutionState::end(nsresult aResult) {
+ NS_ASSERTION(NS_FAILED(aResult) || mTemplateRules.Length() == 1,
+ "Didn't clean up template rules properly");
+ if (NS_SUCCEEDED(aResult)) {
+ popTemplateRule();
+ } else if (!mOutputHandler) {
+ return NS_OK;
+ }
+ return mOutputHandler->endDocument(aResult);
+}
+
+void txExecutionState::popAndDeleteEvalContextUntil(txIEvalContext* aContext) {
+ auto ctx = popEvalContext();
+ while (ctx && ctx != aContext) {
+ MOZ_RELEASE_ASSERT(ctx != mInitialEvalContext);
+ delete ctx;
+ ctx = popEvalContext();
+ }
+}
+
+nsresult txExecutionState::getVariable(int32_t aNamespace, nsAtom* aLName,
+ txAExprResult*& aResult) {
+ nsresult rv = NS_OK;
+ txExpandedName name(aNamespace, aLName);
+
+ // look for a local variable
+ if (mLocalVariables) {
+ mLocalVariables->getVariable(name, &aResult);
+ if (aResult) {
+ return NS_OK;
+ }
+ }
+
+ // look for an evaluated global variable
+ mGlobalVariableValues.getVariable(name, &aResult);
+ if (aResult) {
+ if (aResult == mGlobalVarPlaceholderValue) {
+ // XXX ErrorReport: cyclic variable-value
+ NS_RELEASE(aResult);
+ return NS_ERROR_XSLT_BAD_RECURSION;
+ }
+ return NS_OK;
+ }
+
+ // Is there perchance a global variable not evaluated yet?
+ txStylesheet::GlobalVariable* var = mStylesheet->getGlobalVariable(name);
+ if (!var) {
+ // XXX ErrorReport: variable doesn't exist in this scope
+ return NS_ERROR_FAILURE;
+ }
+
+ NS_ASSERTION((var->mExpr && !var->mFirstInstruction) ||
+ (!var->mExpr && var->mFirstInstruction),
+ "global variable should have either instruction or expression");
+
+ // Is this a stylesheet parameter that has a value?
+ if (var->mIsParam && mGlobalParams) {
+ txIGlobalParameter* param = mGlobalParams->get(name);
+ if (param) {
+ rv = param->getValue(&aResult);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = mGlobalVariableValues.bindVariable(name, aResult);
+ if (NS_FAILED(rv)) {
+ NS_RELEASE(aResult);
+ return rv;
+ }
+
+ return NS_OK;
+ }
+ }
+
+ // Insert a placeholdervalue to protect against recursion
+ rv = mGlobalVariableValues.bindVariable(name, mGlobalVarPlaceholderValue);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // evaluate the global variable
+ pushEvalContext(mInitialEvalContext);
+ if (var->mExpr) {
+ txVariableMap* oldVars = mLocalVariables;
+ mLocalVariables = nullptr;
+ rv = var->mExpr->evaluate(getEvalContext(), &aResult);
+ mLocalVariables = oldVars;
+
+ if (NS_FAILED(rv)) {
+ popAndDeleteEvalContextUntil(mInitialEvalContext);
+ return rv;
+ }
+ } else {
+ pushResultHandler(new txRtfHandler);
+
+ txInstruction* prevInstr = mNextInstruction;
+ // set return to nullptr to stop execution
+ mNextInstruction = nullptr;
+ rv = runTemplate(var->mFirstInstruction.get());
+ if (NS_FAILED(rv)) {
+ popAndDeleteEvalContextUntil(mInitialEvalContext);
+ return rv;
+ }
+
+ pushTemplateRule(nullptr, txExpandedName(), nullptr);
+ rv = txXSLTProcessor::execute(*this);
+ if (NS_FAILED(rv)) {
+ popAndDeleteEvalContextUntil(mInitialEvalContext);
+ return rv;
+ }
+
+ popTemplateRule();
+
+ mNextInstruction = prevInstr;
+ UniquePtr<txRtfHandler> rtfHandler(
+ static_cast<txRtfHandler*>(popResultHandler()));
+ rv = rtfHandler->getAsRTF(&aResult);
+ if (NS_FAILED(rv)) {
+ popAndDeleteEvalContextUntil(mInitialEvalContext);
+ return rv;
+ }
+ }
+ popEvalContext();
+
+ // Remove the placeholder and insert the calculated value
+ mGlobalVariableValues.removeVariable(name);
+ rv = mGlobalVariableValues.bindVariable(name, aResult);
+ if (NS_FAILED(rv)) {
+ NS_RELEASE(aResult);
+
+ return rv;
+ }
+
+ return NS_OK;
+}
+
+nsresult txExecutionState::isStripSpaceAllowed(const txXPathNode& aNode,
+ bool& aAllowed) {
+ return mStylesheet->isStripSpaceAllowed(aNode, this, aAllowed);
+}
+
+void* txExecutionState::getPrivateContext() { return this; }
+
+txResultRecycler* txExecutionState::recycler() { return mRecycler; }
+
+void txExecutionState::receiveError(const nsAString& aMsg, nsresult aRes) {
+ // XXX implement me
+}
+
+void txExecutionState::pushEvalContext(txIEvalContext* aContext) {
+ mEvalContextStack.push(mEvalContext);
+ mEvalContext = aContext;
+}
+
+txIEvalContext* txExecutionState::popEvalContext() {
+ txIEvalContext* prev = mEvalContext;
+ mEvalContext = (txIEvalContext*)mEvalContextStack.pop();
+
+ return prev;
+}
+
+void txExecutionState::pushBool(bool aBool) { mBoolStack.AppendElement(aBool); }
+
+bool txExecutionState::popBool() {
+ NS_ASSERTION(mBoolStack.Length(), "popping from empty stack");
+
+ return mBoolStack.IsEmpty() ? false : mBoolStack.PopLastElement();
+}
+
+void txExecutionState::pushResultHandler(txAXMLEventHandler* aHandler) {
+ mResultHandlerStack.push(mResultHandler);
+ mResultHandler = aHandler;
+}
+
+txAXMLEventHandler* txExecutionState::popResultHandler() {
+ txAXMLEventHandler* oldHandler = mResultHandler;
+ mResultHandler = (txAXMLEventHandler*)mResultHandlerStack.pop();
+
+ return oldHandler;
+}
+
+void txExecutionState::pushTemplateRule(txStylesheet::ImportFrame* aFrame,
+ const txExpandedName& aMode,
+ txParameterMap* aParams) {
+ TemplateRule* rule = mTemplateRules.AppendElement();
+ rule->mFrame = aFrame;
+ rule->mModeNsId = aMode.mNamespaceID;
+ rule->mModeLocalName = aMode.mLocalName;
+ rule->mParams = aParams;
+}
+
+void txExecutionState::popTemplateRule() {
+ MOZ_ASSERT(!mTemplateRules.IsEmpty(), "No rules to pop");
+ mTemplateRules.RemoveLastElement();
+}
+
+txIEvalContext* txExecutionState::getEvalContext() { return mEvalContext; }
+
+const txXPathNode* txExecutionState::retrieveDocument(const nsAString& aUri) {
+ NS_ASSERTION(!aUri.Contains(char16_t('#')), "Remove the fragment.");
+
+ if (mDisableLoads) {
+ return nullptr;
+ }
+
+ MOZ_LOG(txLog::xslt, mozilla::LogLevel::Debug,
+ ("Retrieve Document %s", NS_LossyConvertUTF16toASCII(aUri).get()));
+
+ // try to get already loaded document
+ txLoadedDocumentEntry* entry = mLoadedDocuments.PutEntry(aUri);
+ if (!entry) {
+ return nullptr;
+ }
+
+ if (!entry->mDocument && !entry->LoadingFailed()) {
+ // open URI
+ nsAutoString errMsg;
+ // XXX we should get the loader from the actual node
+ // triggering the load, but this will do for the time being
+ entry->mLoadResult =
+ txParseDocumentFromURI(aUri, *mLoadedDocuments.mSourceDocument, errMsg,
+ getter_Transfers(entry->mDocument));
+
+ if (entry->LoadingFailed()) {
+ receiveError(u"Couldn't load document '"_ns + aUri + u"': "_ns + errMsg,
+ entry->mLoadResult);
+ }
+ }
+
+ return entry->mDocument.get();
+}
+
+nsresult txExecutionState::getKeyNodes(const txExpandedName& aKeyName,
+ const txXPathNode& aRoot,
+ const nsAString& aKeyValue,
+ bool aIndexIfNotFound,
+ txNodeSet** aResult) {
+ return mKeyHash.getKeyNodes(aKeyName, aRoot, aKeyValue, aIndexIfNotFound,
+ *this, aResult);
+}
+
+txExecutionState::TemplateRule* txExecutionState::getCurrentTemplateRule() {
+ MOZ_ASSERT(!mTemplateRules.IsEmpty(), "No current rule!");
+ return &mTemplateRules[mTemplateRules.Length() - 1];
+}
+
+mozilla::Result<txInstruction*, nsresult>
+txExecutionState::getNextInstruction() {
+ if (mStopProcessing) {
+ return mozilla::Err(NS_ERROR_FAILURE);
+ }
+
+ txInstruction* instr = mNextInstruction;
+ if (instr) {
+ mNextInstruction = instr->mNext.get();
+ }
+
+ return instr;
+}
+
+nsresult txExecutionState::runTemplate(txInstruction* aTemplate) {
+ NS_ENSURE_TRUE(++mRecursionDepth < kMaxRecursionDepth,
+ NS_ERROR_XSLT_BAD_RECURSION);
+
+ mLocalVarsStack.push(mLocalVariables);
+ mReturnStack.push(mNextInstruction);
+
+ mLocalVariables = nullptr;
+ mNextInstruction = aTemplate;
+
+ return NS_OK;
+}
+
+void txExecutionState::gotoInstruction(txInstruction* aNext) {
+ mNextInstruction = aNext;
+}
+
+void txExecutionState::returnFromTemplate() {
+ --mRecursionDepth;
+ NS_ASSERTION(!mReturnStack.isEmpty() && !mLocalVarsStack.isEmpty(),
+ "return or variable stack is empty");
+ delete mLocalVariables;
+ mNextInstruction = (txInstruction*)mReturnStack.pop();
+ mLocalVariables = (txVariableMap*)mLocalVarsStack.pop();
+}
+
+nsresult txExecutionState::bindVariable(const txExpandedName& aName,
+ txAExprResult* aValue) {
+ if (!mLocalVariables) {
+ mLocalVariables = new txVariableMap;
+ }
+ return mLocalVariables->bindVariable(aName, aValue);
+}
+
+void txExecutionState::removeVariable(const txExpandedName& aName) {
+ mLocalVariables->removeVariable(aName);
+}
+
+void txExecutionState::pushParamMap(txParameterMap* aParams) {
+ mParamStack.AppendElement(mTemplateParams.forget());
+ mTemplateParams = aParams;
+}
+
+already_AddRefed<txParameterMap> txExecutionState::popParamMap() {
+ RefPtr<txParameterMap> oldParams = std::move(mTemplateParams);
+ mTemplateParams = mParamStack.PopLastElement();
+
+ return oldParams.forget();
+}
diff --git a/dom/xslt/xslt/txExecutionState.h b/dom/xslt/xslt/txExecutionState.h
new file mode 100644
index 0000000000..7a314cf8a4
--- /dev/null
+++ b/dom/xslt/xslt/txExecutionState.h
@@ -0,0 +1,166 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef TRANSFRMX_TXEXECUTIONSTATE_H
+#define TRANSFRMX_TXEXECUTIONSTATE_H
+
+#include "txCore.h"
+#include "txStack.h"
+#include "txXMLUtils.h"
+#include "txIXPathContext.h"
+#include "txVariableMap.h"
+#include "nsTHashtable.h"
+#include "nsHashKeys.h"
+#include "txKey.h"
+#include "txStylesheet.h"
+#include "txXPathTreeWalker.h"
+#include "nsTArray.h"
+#include "mozilla/Result.h"
+
+class txAOutputHandlerFactory;
+class txAXMLEventHandler;
+class txInstruction;
+
+class txLoadedDocumentEntry : public nsStringHashKey {
+ public:
+ explicit txLoadedDocumentEntry(KeyTypePointer aStr)
+ : nsStringHashKey(aStr), mLoadResult(NS_OK) {}
+ txLoadedDocumentEntry(txLoadedDocumentEntry&& aOther)
+ : nsStringHashKey(std::move(aOther)),
+ mDocument(std::move(aOther.mDocument)),
+ mLoadResult(std::move(aOther.mLoadResult)) {
+ NS_ERROR("We're horked.");
+ }
+ ~txLoadedDocumentEntry() {
+ if (mDocument) {
+ txXPathNodeUtils::release(mDocument.get());
+ }
+ }
+ bool LoadingFailed() {
+ NS_ASSERTION(NS_SUCCEEDED(mLoadResult) || !mDocument,
+ "Load failed but we still got a document?");
+
+ return NS_FAILED(mLoadResult);
+ }
+
+ mozilla::UniquePtr<txXPathNode> mDocument;
+ nsresult mLoadResult;
+};
+
+class txLoadedDocumentsHash : public nsTHashtable<txLoadedDocumentEntry> {
+ public:
+ txLoadedDocumentsHash() : nsTHashtable<txLoadedDocumentEntry>(4) {}
+ ~txLoadedDocumentsHash();
+ [[nodiscard]] nsresult init(const txXPathNode& aSource);
+
+ private:
+ friend class txExecutionState;
+ mozilla::UniquePtr<txXPathNode> mSourceDocument;
+};
+
+class txExecutionState : public txIMatchContext {
+ public:
+ txExecutionState(txStylesheet* aStylesheet, bool aDisableLoads);
+ ~txExecutionState();
+ nsresult init(const txXPathNode& aNode,
+ txOwningExpandedNameMap<txIGlobalParameter>* aGlobalParams);
+ nsresult end(nsresult aResult);
+
+ TX_DECL_MATCH_CONTEXT;
+
+ /**
+ * Struct holding information about a current template rule
+ */
+ class TemplateRule {
+ public:
+ txStylesheet::ImportFrame* mFrame;
+ int32_t mModeNsId;
+ RefPtr<nsAtom> mModeLocalName;
+ RefPtr<txParameterMap> mParams;
+ };
+
+ // Stack functions
+ void pushEvalContext(txIEvalContext* aContext);
+ txIEvalContext* popEvalContext();
+
+ /**
+ * Helper that deletes all entries before |aContext| and then
+ * pops it off the stack. The caller must delete |aContext| if
+ * desired.
+ */
+ void popAndDeleteEvalContextUntil(txIEvalContext* aContext);
+
+ void pushBool(bool aBool);
+ bool popBool();
+ void pushResultHandler(txAXMLEventHandler* aHandler);
+ txAXMLEventHandler* popResultHandler();
+ void pushTemplateRule(txStylesheet::ImportFrame* aFrame,
+ const txExpandedName& aMode, txParameterMap* aParams);
+ void popTemplateRule();
+ void pushParamMap(txParameterMap* aParams);
+ already_AddRefed<txParameterMap> popParamMap();
+
+ // state-getting functions
+ txIEvalContext* getEvalContext();
+ const txXPathNode* retrieveDocument(const nsAString& aUri);
+ nsresult getKeyNodes(const txExpandedName& aKeyName, const txXPathNode& aRoot,
+ const nsAString& aKeyValue, bool aIndexIfNotFound,
+ txNodeSet** aResult);
+ TemplateRule* getCurrentTemplateRule();
+ const txXPathNode& getSourceDocument() {
+ NS_ASSERTION(mLoadedDocuments.mSourceDocument, "Need a source document!");
+
+ return *mLoadedDocuments.mSourceDocument;
+ }
+
+ // state-modification functions
+ mozilla::Result<txInstruction*, nsresult> getNextInstruction();
+ nsresult runTemplate(txInstruction* aInstruction);
+ nsresult runTemplate(txInstruction* aInstruction, txInstruction* aReturnTo);
+ void gotoInstruction(txInstruction* aNext);
+ void returnFromTemplate();
+ nsresult bindVariable(const txExpandedName& aName, txAExprResult* aValue);
+ void removeVariable(const txExpandedName& aName);
+ void stopProcessing() { mStopProcessing = true; }
+
+ txAXMLEventHandler* mOutputHandler;
+ txAXMLEventHandler* mResultHandler;
+ mozilla::UniquePtr<txAXMLEventHandler> mObsoleteHandler;
+ txAOutputHandlerFactory* mOutputHandlerFactory;
+
+ RefPtr<txParameterMap> mTemplateParams;
+
+ RefPtr<txStylesheet> mStylesheet;
+
+ private:
+ txStack mReturnStack;
+ txStack mLocalVarsStack;
+ txStack mEvalContextStack;
+ nsTArray<bool> mBoolStack;
+ txStack mResultHandlerStack;
+ nsTArray<RefPtr<txParameterMap>> mParamStack;
+ txInstruction* mNextInstruction;
+ txVariableMap* mLocalVariables;
+ txVariableMap mGlobalVariableValues;
+ RefPtr<txAExprResult> mGlobalVarPlaceholderValue;
+ int32_t mRecursionDepth;
+
+ AutoTArray<TemplateRule, 10> mTemplateRules;
+
+ txIEvalContext* mEvalContext;
+ txIEvalContext* mInitialEvalContext;
+ // Document* mRTFDocument;
+ txOwningExpandedNameMap<txIGlobalParameter>* mGlobalParams;
+
+ txLoadedDocumentsHash mLoadedDocuments;
+ txKeyHash mKeyHash;
+ RefPtr<txResultRecycler> mRecycler;
+ bool mDisableLoads;
+ bool mStopProcessing = false;
+
+ static const int32_t kMaxRecursionDepth;
+};
+
+#endif
diff --git a/dom/xslt/xslt/txFormatNumberFunctionCall.cpp b/dom/xslt/xslt/txFormatNumberFunctionCall.cpp
new file mode 100644
index 0000000000..e851db2d7e
--- /dev/null
+++ b/dom/xslt/xslt/txFormatNumberFunctionCall.cpp
@@ -0,0 +1,406 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/FloatingPoint.h"
+
+#include "txXSLTFunctions.h"
+#include "nsGkAtoms.h"
+#include "txIXPathContext.h"
+#include "txStylesheet.h"
+#include <math.h>
+#include "txNamespaceMap.h"
+
+#include "prdtoa.h"
+
+#define INVALID_PARAM_VALUE u"invalid parameter value for function"_ns
+
+const char16_t txFormatNumberFunctionCall::FORMAT_QUOTE = '\'';
+
+/*
+ * FormatNumberFunctionCall
+ * A representation of the XSLT additional function: format-number()
+ */
+
+/*
+ * Creates a new format-number function call
+ */
+txFormatNumberFunctionCall::txFormatNumberFunctionCall(
+ txStylesheet* aStylesheet, txNamespaceMap* aMappings)
+ : mStylesheet(aStylesheet), mMappings(aMappings) {}
+
+void txFormatNumberFunctionCall::ReportInvalidArg(txIEvalContext* aContext) {
+ nsAutoString err(INVALID_PARAM_VALUE);
+#ifdef TX_TO_STRING
+ err.AppendLiteral(": ");
+ toString(err);
+#endif
+ aContext->receiveError(err, NS_ERROR_XPATH_INVALID_ARG);
+}
+
+/*
+ * Evaluates this Expr based on the given context node and processor state
+ * @param context the context node for evaluation of this Expr
+ * @param cs the ContextState containing the stack information needed
+ * for evaluation
+ * @return the result of the evaluation
+ */
+nsresult txFormatNumberFunctionCall::evaluate(txIEvalContext* aContext,
+ txAExprResult** aResult) {
+ *aResult = nullptr;
+ if (!requireParams(2, 3, aContext)) return NS_ERROR_XPATH_BAD_ARGUMENT_COUNT;
+
+ // Get number and format
+ double value;
+ txExpandedName formatName;
+
+ nsresult rv = evaluateToNumber(mParams[0], aContext, &value);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ nsAutoString formatStr;
+ rv = mParams[1]->evaluateToString(aContext, formatStr);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (mParams.Length() == 3) {
+ nsAutoString formatQName;
+ rv = mParams[2]->evaluateToString(aContext, formatQName);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = formatName.init(formatQName, mMappings, false);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ txDecimalFormat* format = mStylesheet->getDecimalFormat(formatName);
+ if (!format) {
+ nsAutoString err(u"unknown decimal format"_ns);
+#ifdef TX_TO_STRING
+ err.AppendLiteral(" for: ");
+ toString(err);
+#endif
+ aContext->receiveError(err, NS_ERROR_XPATH_INVALID_ARG);
+ return NS_ERROR_XPATH_INVALID_ARG;
+ }
+
+ // Special cases
+ if (std::isnan(value)) {
+ return aContext->recycler()->getStringResult(format->mNaN, aResult);
+ }
+
+ if (value == mozilla::PositiveInfinity<double>()) {
+ return aContext->recycler()->getStringResult(format->mInfinity, aResult);
+ }
+
+ if (value == mozilla::NegativeInfinity<double>()) {
+ nsAutoString res;
+ res.Append(format->mMinusSign);
+ res.Append(format->mInfinity);
+ return aContext->recycler()->getStringResult(res, aResult);
+ }
+
+ // Value is a normal finite number
+ nsAutoString prefix;
+ nsAutoString suffix;
+ int minIntegerSize = 0;
+ int minFractionSize = 0;
+ int maxFractionSize = 0;
+ int multiplier = 1;
+ int groupSize = -1;
+
+ uint32_t pos = 0;
+ uint32_t formatLen = formatStr.Length();
+ bool inQuote;
+
+ // Get right subexpression
+ inQuote = false;
+ if (mozilla::IsNegative(value)) {
+ while (pos < formatLen &&
+ (inQuote || formatStr.CharAt(pos) != format->mPatternSeparator)) {
+ if (formatStr.CharAt(pos) == FORMAT_QUOTE) inQuote = !inQuote;
+ pos++;
+ }
+
+ if (pos == formatLen) {
+ pos = 0;
+ prefix.Append(format->mMinusSign);
+ } else
+ pos++;
+ }
+
+ // Parse the format string
+ FormatParseState pState = Prefix;
+ inQuote = false;
+
+ char16_t c = 0;
+ while (pos < formatLen && pState != Finished) {
+ c = formatStr.CharAt(pos++);
+
+ switch (pState) {
+ case Prefix:
+ case Suffix:
+ if (!inQuote) {
+ if (c == format->mPercent) {
+ if (multiplier == 1)
+ multiplier = 100;
+ else {
+ ReportInvalidArg(aContext);
+ return NS_ERROR_XPATH_INVALID_ARG;
+ }
+ } else if (c == format->mPerMille) {
+ if (multiplier == 1)
+ multiplier = 1000;
+ else {
+ ReportInvalidArg(aContext);
+ return NS_ERROR_XPATH_INVALID_ARG;
+ }
+ } else if (c == format->mDecimalSeparator ||
+ c == format->mGroupingSeparator ||
+ c == format->mZeroDigit || c == format->mDigit ||
+ c == format->mPatternSeparator) {
+ pState = pState == Prefix ? IntDigit : Finished;
+ pos--;
+ break;
+ }
+ }
+
+ if (c == FORMAT_QUOTE)
+ inQuote = !inQuote;
+ else if (pState == Prefix)
+ prefix.Append(c);
+ else
+ suffix.Append(c);
+ break;
+
+ case IntDigit:
+ if (c == format->mGroupingSeparator)
+ groupSize = 0;
+ else if (c == format->mDigit) {
+ if (groupSize >= 0) groupSize++;
+ } else {
+ pState = IntZero;
+ pos--;
+ }
+ break;
+
+ case IntZero:
+ if (c == format->mGroupingSeparator)
+ groupSize = 0;
+ else if (c == format->mZeroDigit) {
+ if (groupSize >= 0) groupSize++;
+ minIntegerSize++;
+ } else if (c == format->mDecimalSeparator) {
+ pState = FracZero;
+ } else {
+ pState = Suffix;
+ pos--;
+ }
+ break;
+
+ case FracZero:
+ if (c == format->mZeroDigit) {
+ maxFractionSize++;
+ minFractionSize++;
+ } else {
+ pState = FracDigit;
+ pos--;
+ }
+ break;
+
+ case FracDigit:
+ if (c == format->mDigit)
+ maxFractionSize++;
+ else {
+ pState = Suffix;
+ pos--;
+ }
+ break;
+
+ case Finished:
+ break;
+ }
+ }
+
+ // Did we manage to parse the entire formatstring and was it valid
+ if ((c != format->mPatternSeparator && pos < formatLen) || inQuote ||
+ groupSize == 0) {
+ ReportInvalidArg(aContext);
+ return NS_ERROR_XPATH_INVALID_ARG;
+ }
+
+ /*
+ * FINALLY we're done with the parsing
+ * now build the result string
+ */
+
+ value = fabs(value) * multiplier;
+
+ // Make sure the multiplier didn't push value to infinity.
+ if (value == mozilla::PositiveInfinity<double>()) {
+ return aContext->recycler()->getStringResult(format->mInfinity, aResult);
+ }
+
+ // Make sure the multiplier didn't push value to infinity.
+ if (value == mozilla::PositiveInfinity<double>()) {
+ return aContext->recycler()->getStringResult(format->mInfinity, aResult);
+ }
+
+ // Prefix
+ nsAutoString res(prefix);
+
+ int bufsize;
+ if (value > 1)
+ bufsize = (int)log10(value) + 30;
+ else
+ bufsize = 1 + 30;
+
+ auto buf = mozilla::MakeUnique<char[]>(bufsize);
+ int bufIntDigits, sign;
+ char* endp;
+ PR_dtoa(value, 0, 0, &bufIntDigits, &sign, &endp, buf.get(), bufsize - 1);
+
+ int buflen = endp - buf.get();
+ int intDigits;
+ intDigits = bufIntDigits > minIntegerSize ? bufIntDigits : minIntegerSize;
+
+ if (groupSize < 0) groupSize = intDigits + 10; // to simplify grouping
+
+ // XXX We shouldn't use SetLength.
+ res.SetLength(res.Length() + intDigits + // integer digits
+ 1 + // decimal separator
+ maxFractionSize + // fractions
+ (intDigits - 1) / groupSize); // group separators
+
+ int32_t i = bufIntDigits + maxFractionSize - 1;
+ bool carry = (0 <= i + 1) && (i + 1 < buflen) && (buf[i + 1] >= '5');
+ bool hasFraction = false;
+
+ // The number of characters in res that we haven't filled in.
+ mozilla::CheckedUint32 resRemain = mozilla::CheckedUint32(res.Length());
+
+#define CHECKED_SET_CHAR(c) \
+ --resRemain; \
+ if (!resRemain.isValid() || !res.SetCharAt(c, resRemain.value())) { \
+ ReportInvalidArg(aContext); \
+ return NS_ERROR_XPATH_INVALID_ARG; \
+ }
+
+#define CHECKED_TRUNCATE() \
+ --resRemain; \
+ if (!resRemain.isValid()) { \
+ ReportInvalidArg(aContext); \
+ return NS_ERROR_XPATH_INVALID_ARG; \
+ } \
+ res.Truncate(resRemain.value());
+
+ // Fractions
+ for (; i >= bufIntDigits; --i) {
+ int digit;
+ if (i >= buflen || i < 0) {
+ digit = 0;
+ } else {
+ digit = buf[i] - '0';
+ }
+
+ if (carry) {
+ digit = (digit + 1) % 10;
+ carry = digit == 0;
+ }
+
+ if (hasFraction || digit != 0 || i < bufIntDigits + minFractionSize) {
+ hasFraction = true;
+ CHECKED_SET_CHAR((char16_t)(digit + format->mZeroDigit));
+ } else {
+ CHECKED_TRUNCATE();
+ }
+ }
+
+ // Decimal separator
+ if (hasFraction) {
+ CHECKED_SET_CHAR(format->mDecimalSeparator);
+ } else {
+ CHECKED_TRUNCATE();
+ }
+
+ // Integer digits
+ for (i = 0; i < intDigits; ++i) {
+ int digit;
+ if (bufIntDigits - i - 1 >= buflen || bufIntDigits - i - 1 < 0) {
+ digit = 0;
+ } else {
+ digit = buf[bufIntDigits - i - 1] - '0';
+ }
+
+ if (carry) {
+ digit = (digit + 1) % 10;
+ carry = digit == 0;
+ }
+
+ if (i != 0 && i % groupSize == 0) {
+ CHECKED_SET_CHAR(format->mGroupingSeparator);
+ }
+
+ CHECKED_SET_CHAR((char16_t)(digit + format->mZeroDigit));
+ }
+
+#undef CHECKED_SET_CHAR
+#undef CHECKED_TRUNCATE
+
+ if (carry) {
+ if (i % groupSize == 0) {
+ res.Insert(format->mGroupingSeparator, resRemain.value());
+ }
+ res.Insert((char16_t)(1 + format->mZeroDigit), resRemain.value());
+ }
+
+ if (!hasFraction && !intDigits && !carry) {
+ // If we havn't added any characters we add a '0'
+ // This can only happen for formats like '##.##'
+ res.Append(format->mZeroDigit);
+ }
+
+ // Build suffix
+ res.Append(suffix);
+
+ return aContext->recycler()->getStringResult(res, aResult);
+} //-- evaluate
+
+Expr::ResultType txFormatNumberFunctionCall::getReturnType() {
+ return STRING_RESULT;
+}
+
+bool txFormatNumberFunctionCall::isSensitiveTo(ContextSensitivity aContext) {
+ return argsSensitiveTo(aContext);
+}
+
+#ifdef TX_TO_STRING
+void txFormatNumberFunctionCall::appendName(nsAString& aDest) {
+ aDest.Append(nsGkAtoms::formatNumber->GetUTF16String());
+}
+#endif
+
+/*
+ * txDecimalFormat
+ * A representation of the XSLT element <xsl:decimal-format>
+ */
+
+txDecimalFormat::txDecimalFormat()
+ : mInfinity(u"Infinity"_ns), mNaN(u"NaN"_ns) {
+ mDecimalSeparator = '.';
+ mGroupingSeparator = ',';
+ mMinusSign = '-';
+ mPercent = '%';
+ mPerMille = 0x2030;
+ mZeroDigit = '0';
+ mDigit = '#';
+ mPatternSeparator = ';';
+}
+
+bool txDecimalFormat::isEqual(txDecimalFormat* other) {
+ return mDecimalSeparator == other->mDecimalSeparator &&
+ mGroupingSeparator == other->mGroupingSeparator &&
+ mInfinity.Equals(other->mInfinity) &&
+ mMinusSign == other->mMinusSign && mNaN.Equals(other->mNaN) &&
+ mPercent == other->mPercent && mPerMille == other->mPerMille &&
+ mZeroDigit == other->mZeroDigit && mDigit == other->mDigit &&
+ mPatternSeparator == other->mPatternSeparator;
+}
diff --git a/dom/xslt/xslt/txGenerateIdFunctionCall.cpp b/dom/xslt/xslt/txGenerateIdFunctionCall.cpp
new file mode 100644
index 0000000000..775d8a0a81
--- /dev/null
+++ b/dom/xslt/xslt/txGenerateIdFunctionCall.cpp
@@ -0,0 +1,99 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsGkAtoms.h"
+#include "txIXPathContext.h"
+#include "txNodeSet.h"
+#include "txXPathTreeWalker.h"
+#include "txXSLTFunctions.h"
+#include "txExecutionState.h"
+
+/*
+ Implementation of XSLT 1.0 extension function: generate-id
+*/
+
+/**
+ * Creates a new generate-id function call
+ **/
+GenerateIdFunctionCall::GenerateIdFunctionCall() = default;
+
+/**
+ * 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;
+}
+
+Expr::ResultType GenerateIdFunctionCall::getReturnType() {
+ return STRING_RESULT;
+}
+
+bool GenerateIdFunctionCall::isSensitiveTo(ContextSensitivity aContext) {
+ if (aContext & PRIVATE_CONTEXT) {
+ return true;
+ }
+
+ if (mParams.IsEmpty()) {
+ return !!(aContext & NODE_CONTEXT);
+ }
+
+ return argsSensitiveTo(aContext);
+}
+
+#ifdef TX_TO_STRING
+void GenerateIdFunctionCall::appendName(nsAString& aDest) {
+ aDest.Append(nsGkAtoms::generateId->GetUTF16String());
+}
+#endif
diff --git a/dom/xslt/xslt/txIEXSLTFunctions.idl b/dom/xslt/xslt/txIEXSLTFunctions.idl
new file mode 100644
index 0000000000..7514a5e4a1
--- /dev/null
+++ b/dom/xslt/xslt/txIEXSLTFunctions.idl
@@ -0,0 +1,20 @@
+/* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 8 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+webidl Document;
+webidl DocumentFragment;
+
+[scriptable, uuid(21b1cfa4-00ce-4cc1-bfc1-92af1d00e580)]
+interface txIEXSLTFunctions : nsISupports {
+ DocumentFragment match(in AString str, in AString regex,
+ in AString flags, in Document doc);
+
+ AString replace(in AString str, in AString regex, in AString flags,
+ in AString replace);
+
+ boolean test(in AString str, in AString regex, in AString flags);
+};
diff --git a/dom/xslt/xslt/txInstructions.cpp b/dom/xslt/xslt/txInstructions.cpp
new file mode 100644
index 0000000000..df6e1ffeb0
--- /dev/null
+++ b/dom/xslt/xslt/txInstructions.cpp
@@ -0,0 +1,764 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txInstructions.h"
+
+#include <utility>
+
+#include "nsError.h"
+#include "nsGkAtoms.h"
+#include "nsIConsoleService.h"
+#include "nsServiceManagerUtils.h"
+#include "txExecutionState.h"
+#include "txExpr.h"
+#include "txNodeSetContext.h"
+#include "txNodeSorter.h"
+#include "txRtfHandler.h"
+#include "txStringUtils.h"
+#include "txStylesheet.h"
+#include "txTextHandler.h"
+#include "txXSLTNumber.h"
+
+using mozilla::MakeUnique;
+using mozilla::UniquePtr;
+
+nsresult txApplyDefaultElementTemplate::execute(txExecutionState& aEs) {
+ txExecutionState::TemplateRule* rule = aEs.getCurrentTemplateRule();
+ txExpandedName mode(rule->mModeNsId, rule->mModeLocalName);
+ txStylesheet::ImportFrame* frame = 0;
+ txInstruction* templ;
+ nsresult rv =
+ aEs.mStylesheet->findTemplate(aEs.getEvalContext()->getContextNode(),
+ mode, &aEs, nullptr, &templ, &frame);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aEs.pushTemplateRule(frame, mode, aEs.mTemplateParams);
+
+ return aEs.runTemplate(templ);
+}
+
+nsresult txApplyImportsEnd::execute(txExecutionState& aEs) {
+ aEs.popTemplateRule();
+ RefPtr<txParameterMap> paramMap = aEs.popParamMap();
+
+ return NS_OK;
+}
+
+nsresult txApplyImportsStart::execute(txExecutionState& aEs) {
+ txExecutionState::TemplateRule* rule = aEs.getCurrentTemplateRule();
+ // The frame is set to null when there is no current template rule, or
+ // when the current template rule is a default template. However this
+ // instruction isn't used in default templates.
+ if (!rule->mFrame) {
+ // XXX ErrorReport: apply-imports instantiated without a current rule
+ return NS_ERROR_XSLT_EXECUTION_FAILURE;
+ }
+
+ aEs.pushParamMap(rule->mParams);
+
+ txStylesheet::ImportFrame* frame = 0;
+ txExpandedName mode(rule->mModeNsId, rule->mModeLocalName);
+ txInstruction* templ;
+ nsresult rv =
+ aEs.mStylesheet->findTemplate(aEs.getEvalContext()->getContextNode(),
+ mode, &aEs, rule->mFrame, &templ, &frame);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aEs.pushTemplateRule(frame, mode, rule->mParams);
+
+ rv = aEs.runTemplate(templ);
+ if (NS_FAILED(rv)) {
+ aEs.popTemplateRule();
+ }
+
+ return rv;
+}
+
+txApplyTemplates::txApplyTemplates(const txExpandedName& aMode)
+ : mMode(aMode) {}
+
+nsresult txApplyTemplates::execute(txExecutionState& aEs) {
+ txStylesheet::ImportFrame* frame = 0;
+ txInstruction* templ;
+ nsresult rv =
+ aEs.mStylesheet->findTemplate(aEs.getEvalContext()->getContextNode(),
+ mMode, &aEs, nullptr, &templ, &frame);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aEs.pushTemplateRule(frame, mMode, aEs.mTemplateParams);
+
+ return aEs.runTemplate(templ);
+}
+
+txAttribute::txAttribute(UniquePtr<Expr>&& aName, UniquePtr<Expr>&& aNamespace,
+ txNamespaceMap* aMappings)
+ : mName(std::move(aName)),
+ mNamespace(std::move(aNamespace)),
+ mMappings(aMappings) {}
+
+nsresult txAttribute::execute(txExecutionState& aEs) {
+ UniquePtr<txTextHandler> handler(
+ static_cast<txTextHandler*>(aEs.popResultHandler()));
+
+ nsAutoString name;
+ nsresult rv = mName->evaluateToString(aEs.getEvalContext(), name);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ const char16_t* colon;
+ if (!XMLUtils::isValidQName(name, &colon) ||
+ TX_StringEqualsAtom(name, nsGkAtoms::xmlns)) {
+ return NS_OK;
+ }
+
+ RefPtr<nsAtom> prefix;
+ uint32_t lnameStart = 0;
+ if (colon) {
+ prefix = NS_Atomize(Substring(name.get(), colon));
+ lnameStart = colon - name.get() + 1;
+ }
+
+ int32_t nsId = kNameSpaceID_None;
+ if (mNamespace) {
+ nsAutoString nspace;
+ rv = mNamespace->evaluateToString(aEs.getEvalContext(), nspace);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (!nspace.IsEmpty()) {
+ nsId = txNamespaceManager::getNamespaceID(nspace);
+ }
+ } else if (colon) {
+ nsId = mMappings->lookupNamespace(prefix);
+ }
+
+ // add attribute if everything was ok
+ return nsId != kNameSpaceID_Unknown
+ ? aEs.mResultHandler->attribute(
+ prefix, Substring(name, lnameStart), nsId, handler->mValue)
+ : NS_OK;
+}
+
+txCallTemplate::txCallTemplate(const txExpandedName& aName) : mName(aName) {}
+
+nsresult txCallTemplate::execute(txExecutionState& aEs) {
+ txInstruction* instr = aEs.mStylesheet->getNamedTemplate(mName);
+ NS_ENSURE_TRUE(instr, NS_ERROR_XSLT_EXECUTION_FAILURE);
+
+ nsresult rv = aEs.runTemplate(instr);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ return NS_OK;
+}
+
+txCheckParam::txCheckParam(const txExpandedName& aName)
+ : mName(aName), mBailTarget(nullptr) {}
+
+nsresult txCheckParam::execute(txExecutionState& aEs) {
+ nsresult rv = NS_OK;
+ if (aEs.mTemplateParams) {
+ RefPtr<txAExprResult> exprRes;
+ aEs.mTemplateParams->getVariable(mName, getter_AddRefs(exprRes));
+ if (exprRes) {
+ rv = aEs.bindVariable(mName, exprRes);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aEs.gotoInstruction(mBailTarget);
+ }
+ }
+
+ return NS_OK;
+}
+
+txConditionalGoto::txConditionalGoto(UniquePtr<Expr>&& aCondition,
+ txInstruction* aTarget)
+ : mCondition(std::move(aCondition)), mTarget(aTarget) {}
+
+nsresult txConditionalGoto::execute(txExecutionState& aEs) {
+ bool exprRes;
+ nsresult rv = mCondition->evaluateToBool(aEs.getEvalContext(), exprRes);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (!exprRes) {
+ aEs.gotoInstruction(mTarget);
+ }
+
+ return NS_OK;
+}
+
+nsresult txComment::execute(txExecutionState& aEs) {
+ UniquePtr<txTextHandler> handler(
+ static_cast<txTextHandler*>(aEs.popResultHandler()));
+ uint32_t length = handler->mValue.Length();
+ int32_t pos = 0;
+ while ((pos = handler->mValue.FindChar('-', (uint32_t)pos)) != kNotFound) {
+ ++pos;
+ if ((uint32_t)pos == length || handler->mValue.CharAt(pos) == '-') {
+ handler->mValue.Insert(char16_t(' '), pos++);
+ ++length;
+ }
+ }
+
+ return aEs.mResultHandler->comment(handler->mValue);
+}
+
+nsresult txCopyBase::copyNode(const txXPathNode& aNode, txExecutionState& aEs) {
+ switch (txXPathNodeUtils::getNodeType(aNode)) {
+ case txXPathNodeType::ATTRIBUTE_NODE: {
+ nsAutoString nodeValue;
+ txXPathNodeUtils::appendNodeValue(aNode, nodeValue);
+
+ RefPtr<nsAtom> localName = txXPathNodeUtils::getLocalName(aNode);
+ return aEs.mResultHandler->attribute(
+ txXPathNodeUtils::getPrefix(aNode), localName, nullptr,
+ txXPathNodeUtils::getNamespaceID(aNode), nodeValue);
+ }
+ case txXPathNodeType::COMMENT_NODE: {
+ nsAutoString nodeValue;
+ txXPathNodeUtils::appendNodeValue(aNode, nodeValue);
+ return aEs.mResultHandler->comment(nodeValue);
+ }
+ case txXPathNodeType::DOCUMENT_NODE:
+ case txXPathNodeType::DOCUMENT_FRAGMENT_NODE: {
+ // Copy children
+ txXPathTreeWalker walker(aNode);
+ bool hasChild = walker.moveToFirstChild();
+ while (hasChild) {
+ copyNode(walker.getCurrentPosition(), aEs);
+ hasChild = walker.moveToNextSibling();
+ }
+ break;
+ }
+ case txXPathNodeType::ELEMENT_NODE: {
+ RefPtr<nsAtom> localName = txXPathNodeUtils::getLocalName(aNode);
+ nsresult rv = aEs.mResultHandler->startElement(
+ txXPathNodeUtils::getPrefix(aNode), localName, nullptr,
+ txXPathNodeUtils::getNamespaceID(aNode));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // Copy attributes
+ txXPathTreeWalker walker(aNode);
+ if (walker.moveToFirstAttribute()) {
+ do {
+ nsAutoString nodeValue;
+ walker.appendNodeValue(nodeValue);
+
+ const txXPathNode& attr = walker.getCurrentPosition();
+ localName = txXPathNodeUtils::getLocalName(attr);
+ rv = aEs.mResultHandler->attribute(
+ txXPathNodeUtils::getPrefix(attr), localName, nullptr,
+ txXPathNodeUtils::getNamespaceID(attr), nodeValue);
+ NS_ENSURE_SUCCESS(rv, rv);
+ } while (walker.moveToNextAttribute());
+ walker.moveToParent();
+ }
+
+ // Copy children
+ bool hasChild = walker.moveToFirstChild();
+ while (hasChild) {
+ copyNode(walker.getCurrentPosition(), aEs);
+ hasChild = walker.moveToNextSibling();
+ }
+
+ return aEs.mResultHandler->endElement();
+ }
+ case txXPathNodeType::PROCESSING_INSTRUCTION_NODE: {
+ nsAutoString target, data;
+ txXPathNodeUtils::getNodeName(aNode, target);
+ txXPathNodeUtils::appendNodeValue(aNode, data);
+ return aEs.mResultHandler->processingInstruction(target, data);
+ }
+ case txXPathNodeType::TEXT_NODE:
+ case txXPathNodeType::CDATA_SECTION_NODE: {
+ nsAutoString nodeValue;
+ txXPathNodeUtils::appendNodeValue(aNode, nodeValue);
+ return aEs.mResultHandler->characters(nodeValue, false);
+ }
+ }
+
+ return NS_OK;
+}
+
+txCopy::txCopy() : mBailTarget(nullptr) {}
+
+nsresult txCopy::execute(txExecutionState& aEs) {
+ nsresult rv = NS_OK;
+ const txXPathNode& node = aEs.getEvalContext()->getContextNode();
+
+ switch (txXPathNodeUtils::getNodeType(node)) {
+ case txXPathNodeType::DOCUMENT_NODE:
+ case txXPathNodeType::DOCUMENT_FRAGMENT_NODE: {
+ // "close" current element to ensure that no attributes are added
+ rv = aEs.mResultHandler->characters(u""_ns, false);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aEs.pushBool(false);
+
+ break;
+ }
+ case txXPathNodeType::ELEMENT_NODE: {
+ RefPtr<nsAtom> localName = txXPathNodeUtils::getLocalName(node);
+ rv = aEs.mResultHandler->startElement(
+ txXPathNodeUtils::getPrefix(node), localName, nullptr,
+ txXPathNodeUtils::getNamespaceID(node));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // XXX copy namespace nodes once we have them
+
+ aEs.pushBool(true);
+
+ break;
+ }
+ default: {
+ rv = copyNode(node, aEs);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aEs.gotoInstruction(mBailTarget);
+ }
+ }
+
+ return NS_OK;
+}
+
+txCopyOf::txCopyOf(UniquePtr<Expr>&& aSelect) : mSelect(std::move(aSelect)) {}
+
+nsresult txCopyOf::execute(txExecutionState& aEs) {
+ RefPtr<txAExprResult> exprRes;
+ nsresult rv =
+ mSelect->evaluate(aEs.getEvalContext(), getter_AddRefs(exprRes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ switch (exprRes->getResultType()) {
+ case txAExprResult::NODESET: {
+ txNodeSet* nodes =
+ static_cast<txNodeSet*>(static_cast<txAExprResult*>(exprRes));
+ int32_t i;
+ for (i = 0; i < nodes->size(); ++i) {
+ rv = copyNode(nodes->get(i), aEs);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ break;
+ }
+ case txAExprResult::RESULT_TREE_FRAGMENT: {
+ txResultTreeFragment* rtf = static_cast<txResultTreeFragment*>(
+ static_cast<txAExprResult*>(exprRes));
+ return rtf->flushToHandler(aEs.mResultHandler);
+ }
+ default: {
+ nsAutoString value;
+ exprRes->stringValue(value);
+ if (!value.IsEmpty()) {
+ return aEs.mResultHandler->characters(value, false);
+ }
+ break;
+ }
+ }
+
+ return NS_OK;
+}
+
+nsresult txEndElement::execute(txExecutionState& aEs) {
+ // This will return false if startElement was not called. This happens
+ // when <xsl:element> produces a bad name, or when <xsl:copy> copies a
+ // document node.
+ if (aEs.popBool()) {
+ return aEs.mResultHandler->endElement();
+ }
+
+ return NS_OK;
+}
+
+nsresult txErrorInstruction::execute(txExecutionState& aEs) {
+ // XXX ErrorReport: unknown instruction executed
+ return NS_ERROR_XSLT_EXECUTION_FAILURE;
+}
+
+txGoTo::txGoTo(txInstruction* aTarget) : mTarget(aTarget) {}
+
+nsresult txGoTo::execute(txExecutionState& aEs) {
+ aEs.gotoInstruction(mTarget);
+
+ return NS_OK;
+}
+
+txInsertAttrSet::txInsertAttrSet(const txExpandedName& aName) : mName(aName) {}
+
+nsresult txInsertAttrSet::execute(txExecutionState& aEs) {
+ txInstruction* instr = aEs.mStylesheet->getAttributeSet(mName);
+ NS_ENSURE_TRUE(instr, NS_ERROR_XSLT_EXECUTION_FAILURE);
+
+ nsresult rv = aEs.runTemplate(instr);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ return NS_OK;
+}
+
+txLoopNodeSet::txLoopNodeSet(txInstruction* aTarget) : mTarget(aTarget) {}
+
+nsresult txLoopNodeSet::execute(txExecutionState& aEs) {
+ aEs.popTemplateRule();
+ txNodeSetContext* context =
+ static_cast<txNodeSetContext*>(aEs.getEvalContext());
+ if (!context->hasNext()) {
+ delete aEs.popEvalContext();
+
+ return NS_OK;
+ }
+
+ context->next();
+ aEs.gotoInstruction(mTarget);
+
+ return NS_OK;
+}
+
+txLREAttribute::txLREAttribute(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix, UniquePtr<Expr>&& aValue)
+ : mNamespaceID(aNamespaceID),
+ mLocalName(aLocalName),
+ mPrefix(aPrefix),
+ mValue(std::move(aValue)) {
+ if (aNamespaceID == kNameSpaceID_None) {
+ mLowercaseLocalName = TX_ToLowerCaseAtom(aLocalName);
+ }
+}
+
+nsresult txLREAttribute::execute(txExecutionState& aEs) {
+ RefPtr<txAExprResult> exprRes;
+ nsresult rv = mValue->evaluate(aEs.getEvalContext(), getter_AddRefs(exprRes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ const nsString* value = exprRes->stringValuePointer();
+ if (value) {
+ return aEs.mResultHandler->attribute(
+ mPrefix, mLocalName, mLowercaseLocalName, mNamespaceID, *value);
+ }
+
+ nsAutoString valueStr;
+ exprRes->stringValue(valueStr);
+ return aEs.mResultHandler->attribute(mPrefix, mLocalName, mLowercaseLocalName,
+ mNamespaceID, valueStr);
+}
+
+txMessage::txMessage(bool aTerminate) : mTerminate(aTerminate) {}
+
+nsresult txMessage::execute(txExecutionState& aEs) {
+ UniquePtr<txTextHandler> handler(
+ static_cast<txTextHandler*>(aEs.popResultHandler()));
+
+ nsCOMPtr<nsIConsoleService> consoleSvc =
+ do_GetService("@mozilla.org/consoleservice;1");
+ if (consoleSvc) {
+ nsAutoString logString(u"xsl:message - "_ns);
+ logString.Append(handler->mValue);
+ consoleSvc->LogStringMessage(logString.get());
+ }
+
+ return mTerminate ? NS_ERROR_XSLT_ABORTED : NS_OK;
+}
+
+txNumber::txNumber(txXSLTNumber::LevelType aLevel,
+ UniquePtr<txPattern>&& aCount, UniquePtr<txPattern>&& aFrom,
+ UniquePtr<Expr>&& aValue, UniquePtr<Expr>&& aFormat,
+ UniquePtr<Expr>&& aGroupingSeparator,
+ UniquePtr<Expr>&& aGroupingSize)
+ : mLevel(aLevel),
+ mCount(std::move(aCount)),
+ mFrom(std::move(aFrom)),
+ mValue(std::move(aValue)),
+ mFormat(std::move(aFormat)),
+ mGroupingSeparator(std::move(aGroupingSeparator)),
+ mGroupingSize(std::move(aGroupingSize)) {}
+
+nsresult txNumber::execute(txExecutionState& aEs) {
+ nsAutoString res;
+ nsresult rv = txXSLTNumber::createNumber(
+ mValue.get(), mCount.get(), mFrom.get(), mLevel, mGroupingSize.get(),
+ mGroupingSeparator.get(), mFormat.get(), aEs.getEvalContext(), res);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ return aEs.mResultHandler->characters(res, false);
+}
+
+nsresult txPopParams::execute(txExecutionState& aEs) {
+ RefPtr<txParameterMap> paramMap = aEs.popParamMap();
+
+ return NS_OK;
+}
+
+txProcessingInstruction::txProcessingInstruction(UniquePtr<Expr>&& aName)
+ : mName(std::move(aName)) {}
+
+nsresult txProcessingInstruction::execute(txExecutionState& aEs) {
+ UniquePtr<txTextHandler> handler(
+ static_cast<txTextHandler*>(aEs.popResultHandler()));
+ XMLUtils::normalizePIValue(handler->mValue);
+
+ nsAutoString name;
+ nsresult rv = mName->evaluateToString(aEs.getEvalContext(), name);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // Check name validity (must be valid NCName and a PITarget)
+ // XXX Need to check for NCName and PITarget
+ const char16_t* colon;
+ if (!XMLUtils::isValidQName(name, &colon)) {
+ // XXX ErrorReport: bad PI-target
+ return NS_ERROR_FAILURE;
+ }
+
+ return aEs.mResultHandler->processingInstruction(name, handler->mValue);
+}
+
+txPushNewContext::txPushNewContext(UniquePtr<Expr>&& aSelect)
+ : mSelect(std::move(aSelect)), mBailTarget(nullptr) {}
+
+txPushNewContext::~txPushNewContext() = default;
+
+nsresult txPushNewContext::execute(txExecutionState& aEs) {
+ RefPtr<txAExprResult> exprRes;
+ nsresult rv =
+ mSelect->evaluate(aEs.getEvalContext(), getter_AddRefs(exprRes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (exprRes->getResultType() != txAExprResult::NODESET) {
+ // XXX ErrorReport: nodeset expected
+ return NS_ERROR_XSLT_NODESET_EXPECTED;
+ }
+
+ txNodeSet* nodes =
+ static_cast<txNodeSet*>(static_cast<txAExprResult*>(exprRes));
+
+ if (nodes->isEmpty()) {
+ aEs.gotoInstruction(mBailTarget);
+
+ return NS_OK;
+ }
+
+ txNodeSorter sorter;
+ uint32_t i, count = mSortKeys.Length();
+ for (i = 0; i < count; ++i) {
+ SortKey& sort = mSortKeys[i];
+ rv = sorter.addSortElement(sort.mSelectExpr.get(), sort.mLangExpr.get(),
+ sort.mDataTypeExpr.get(), sort.mOrderExpr.get(),
+ sort.mCaseOrderExpr.get(), aEs.getEvalContext());
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ RefPtr<txNodeSet> sortedNodes;
+ rv = sorter.sortNodeSet(nodes, &aEs, getter_AddRefs(sortedNodes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ auto context = MakeUnique<txNodeSetContext>(sortedNodes, &aEs);
+ context->next();
+
+ aEs.pushEvalContext(context.release());
+
+ return NS_OK;
+}
+
+void txPushNewContext::addSort(UniquePtr<Expr>&& aSelectExpr,
+ UniquePtr<Expr>&& aLangExpr,
+ UniquePtr<Expr>&& aDataTypeExpr,
+ UniquePtr<Expr>&& aOrderExpr,
+ UniquePtr<Expr>&& aCaseOrderExpr) {
+ SortKey* key = mSortKeys.AppendElement();
+ // workaround for not triggering the Copy Constructor
+ key->mSelectExpr = std::move(aSelectExpr);
+ key->mLangExpr = std::move(aLangExpr);
+ key->mDataTypeExpr = std::move(aDataTypeExpr);
+ key->mOrderExpr = std::move(aOrderExpr);
+ key->mCaseOrderExpr = std::move(aCaseOrderExpr);
+}
+
+nsresult txPushNullTemplateRule::execute(txExecutionState& aEs) {
+ aEs.pushTemplateRule(nullptr, txExpandedName(), nullptr);
+ return NS_OK;
+}
+
+nsresult txPushParams::execute(txExecutionState& aEs) {
+ aEs.pushParamMap(nullptr);
+ return NS_OK;
+}
+
+nsresult txPushRTFHandler::execute(txExecutionState& aEs) {
+ aEs.pushResultHandler(new txRtfHandler);
+
+ return NS_OK;
+}
+
+txPushStringHandler::txPushStringHandler(bool aOnlyText)
+ : mOnlyText(aOnlyText) {}
+
+nsresult txPushStringHandler::execute(txExecutionState& aEs) {
+ aEs.pushResultHandler(new txTextHandler(mOnlyText));
+
+ return NS_OK;
+}
+
+txRemoveVariable::txRemoveVariable(const txExpandedName& aName)
+ : mName(aName) {}
+
+nsresult txRemoveVariable::execute(txExecutionState& aEs) {
+ aEs.removeVariable(mName);
+
+ return NS_OK;
+}
+
+nsresult txReturn::execute(txExecutionState& aEs) {
+ NS_ASSERTION(!mNext, "instructions exist after txReturn");
+ aEs.returnFromTemplate();
+
+ return NS_OK;
+}
+
+txSetParam::txSetParam(const txExpandedName& aName, UniquePtr<Expr>&& aValue)
+ : mName(aName), mValue(std::move(aValue)) {}
+
+nsresult txSetParam::execute(txExecutionState& aEs) {
+ nsresult rv = NS_OK;
+ if (!aEs.mTemplateParams) {
+ aEs.mTemplateParams = new txParameterMap;
+ }
+
+ RefPtr<txAExprResult> exprRes;
+ if (mValue) {
+ rv = mValue->evaluate(aEs.getEvalContext(), getter_AddRefs(exprRes));
+ NS_ENSURE_SUCCESS(rv, rv);
+ } else {
+ UniquePtr<txRtfHandler> rtfHandler(
+ static_cast<txRtfHandler*>(aEs.popResultHandler()));
+ rv = rtfHandler->getAsRTF(getter_AddRefs(exprRes));
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ rv = aEs.mTemplateParams->bindVariable(mName, exprRes);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ return NS_OK;
+}
+
+txSetVariable::txSetVariable(const txExpandedName& aName,
+ UniquePtr<Expr>&& aValue)
+ : mName(aName), mValue(std::move(aValue)) {}
+
+nsresult txSetVariable::execute(txExecutionState& aEs) {
+ nsresult rv = NS_OK;
+ RefPtr<txAExprResult> exprRes;
+ if (mValue) {
+ rv = mValue->evaluate(aEs.getEvalContext(), getter_AddRefs(exprRes));
+ NS_ENSURE_SUCCESS(rv, rv);
+ } else {
+ UniquePtr<txRtfHandler> rtfHandler(
+ static_cast<txRtfHandler*>(aEs.popResultHandler()));
+ rv = rtfHandler->getAsRTF(getter_AddRefs(exprRes));
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ return aEs.bindVariable(mName, exprRes);
+}
+
+txStartElement::txStartElement(UniquePtr<Expr>&& aName,
+ UniquePtr<Expr>&& aNamespace,
+ txNamespaceMap* aMappings)
+ : mName(std::move(aName)),
+ mNamespace(std::move(aNamespace)),
+ mMappings(aMappings) {}
+
+nsresult txStartElement::execute(txExecutionState& aEs) {
+ nsAutoString name;
+ nsresult rv = mName->evaluateToString(aEs.getEvalContext(), name);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ int32_t nsId = kNameSpaceID_None;
+ RefPtr<nsAtom> prefix;
+ uint32_t lnameStart = 0;
+
+ const char16_t* colon;
+ if (XMLUtils::isValidQName(name, &colon)) {
+ if (colon) {
+ prefix = NS_Atomize(Substring(name.get(), colon));
+ lnameStart = colon - name.get() + 1;
+ }
+
+ if (mNamespace) {
+ nsAutoString nspace;
+ rv = mNamespace->evaluateToString(aEs.getEvalContext(), nspace);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (!nspace.IsEmpty()) {
+ nsId = txNamespaceManager::getNamespaceID(nspace);
+ }
+ } else {
+ nsId = mMappings->lookupNamespace(prefix);
+ }
+ } else {
+ nsId = kNameSpaceID_Unknown;
+ }
+
+ bool success = true;
+
+ if (nsId != kNameSpaceID_Unknown) {
+ rv = aEs.mResultHandler->startElement(prefix, Substring(name, lnameStart),
+ nsId);
+ } else {
+ rv = NS_ERROR_XSLT_BAD_NODE_NAME;
+ }
+
+ if (rv == NS_ERROR_XSLT_BAD_NODE_NAME) {
+ success = false;
+ // we call characters with an empty string to "close" any element to
+ // make sure that no attributes are added
+ rv = aEs.mResultHandler->characters(u""_ns, false);
+ }
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aEs.pushBool(success);
+
+ return NS_OK;
+}
+
+txStartLREElement::txStartLREElement(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix)
+ : mNamespaceID(aNamespaceID), mLocalName(aLocalName), mPrefix(aPrefix) {
+ if (aNamespaceID == kNameSpaceID_None) {
+ mLowercaseLocalName = TX_ToLowerCaseAtom(aLocalName);
+ }
+}
+
+nsresult txStartLREElement::execute(txExecutionState& aEs) {
+ nsresult rv = aEs.mResultHandler->startElement(
+ mPrefix, mLocalName, mLowercaseLocalName, mNamespaceID);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aEs.pushBool(true);
+
+ return NS_OK;
+}
+
+txText::txText(const nsAString& aStr, bool aDOE) : mStr(aStr), mDOE(aDOE) {}
+
+nsresult txText::execute(txExecutionState& aEs) {
+ return aEs.mResultHandler->characters(mStr, mDOE);
+}
+
+txValueOf::txValueOf(UniquePtr<Expr>&& aExpr, bool aDOE)
+ : mExpr(std::move(aExpr)), mDOE(aDOE) {}
+
+nsresult txValueOf::execute(txExecutionState& aEs) {
+ RefPtr<txAExprResult> exprRes;
+ nsresult rv = mExpr->evaluate(aEs.getEvalContext(), getter_AddRefs(exprRes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ const nsString* value = exprRes->stringValuePointer();
+ if (value) {
+ if (!value->IsEmpty()) {
+ return aEs.mResultHandler->characters(*value, mDOE);
+ }
+ } else {
+ nsAutoString valueStr;
+ exprRes->stringValue(valueStr);
+ if (!valueStr.IsEmpty()) {
+ return aEs.mResultHandler->characters(valueStr, mDOE);
+ }
+ }
+
+ return NS_OK;
+}
diff --git a/dom/xslt/xslt/txInstructions.h b/dom/xslt/xslt/txInstructions.h
new file mode 100644
index 0000000000..5324303704
--- /dev/null
+++ b/dom/xslt/xslt/txInstructions.h
@@ -0,0 +1,362 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef TRANSFRMX_TXINSTRUCTIONS_H
+#define TRANSFRMX_TXINSTRUCTIONS_H
+
+#include "mozilla/UniquePtr.h"
+#include "nsCOMPtr.h"
+#include "txCore.h"
+#include "nsString.h"
+#include "txXMLUtils.h"
+#include "txExpandedName.h"
+#include "txNamespaceMap.h"
+#include "txXSLTNumber.h"
+#include "nsTArray.h"
+
+class nsAtom;
+class txExecutionState;
+
+class txInstruction : public txObject {
+ public:
+ MOZ_COUNTED_DEFAULT_CTOR(txInstruction)
+
+ ~txInstruction() override {
+ MOZ_COUNT_DTOR(txInstruction);
+
+ mozilla::UniquePtr<txInstruction> next(std::move(mNext));
+ while (next) {
+ mozilla::UniquePtr<txInstruction> destroy(std::move(next));
+ next = std::move(destroy->mNext);
+ }
+ }
+
+ virtual nsresult execute(txExecutionState& aEs) = 0;
+
+ mozilla::UniquePtr<txInstruction> mNext;
+};
+
+#define TX_DECL_TXINSTRUCTION \
+ virtual nsresult execute(txExecutionState& aEs) override;
+
+class txApplyDefaultElementTemplate : public txInstruction {
+ public:
+ TX_DECL_TXINSTRUCTION
+};
+
+class txApplyImportsEnd : public txInstruction {
+ public:
+ TX_DECL_TXINSTRUCTION
+};
+
+class txApplyImportsStart : public txInstruction {
+ public:
+ TX_DECL_TXINSTRUCTION
+};
+
+class txApplyTemplates : public txInstruction {
+ public:
+ explicit txApplyTemplates(const txExpandedName& aMode);
+
+ TX_DECL_TXINSTRUCTION
+
+ txExpandedName mMode;
+};
+
+class txAttribute : public txInstruction {
+ public:
+ txAttribute(mozilla::UniquePtr<Expr>&& aName,
+ mozilla::UniquePtr<Expr>&& aNamespace, txNamespaceMap* aMappings);
+
+ TX_DECL_TXINSTRUCTION
+
+ mozilla::UniquePtr<Expr> mName;
+ mozilla::UniquePtr<Expr> mNamespace;
+ RefPtr<txNamespaceMap> mMappings;
+};
+
+class txCallTemplate : public txInstruction {
+ public:
+ explicit txCallTemplate(const txExpandedName& aName);
+
+ TX_DECL_TXINSTRUCTION
+
+ txExpandedName mName;
+};
+
+class txCheckParam : public txInstruction {
+ public:
+ explicit txCheckParam(const txExpandedName& aName);
+
+ TX_DECL_TXINSTRUCTION
+
+ txExpandedName mName;
+ txInstruction* mBailTarget;
+};
+
+class txConditionalGoto : public txInstruction {
+ public:
+ txConditionalGoto(mozilla::UniquePtr<Expr>&& aCondition,
+ txInstruction* aTarget);
+
+ TX_DECL_TXINSTRUCTION
+
+ mozilla::UniquePtr<Expr> mCondition;
+ txInstruction* mTarget;
+};
+
+class txComment : public txInstruction {
+ public:
+ TX_DECL_TXINSTRUCTION
+};
+
+class txCopyBase : public txInstruction {
+ protected:
+ nsresult copyNode(const txXPathNode& aNode, txExecutionState& aEs);
+};
+
+class txCopy : public txCopyBase {
+ public:
+ txCopy();
+
+ TX_DECL_TXINSTRUCTION
+
+ txInstruction* mBailTarget;
+};
+
+class txCopyOf : public txCopyBase {
+ public:
+ explicit txCopyOf(mozilla::UniquePtr<Expr>&& aSelect);
+
+ TX_DECL_TXINSTRUCTION
+
+ mozilla::UniquePtr<Expr> mSelect;
+};
+
+class txEndElement : public txInstruction {
+ public:
+ TX_DECL_TXINSTRUCTION
+};
+
+class txErrorInstruction : public txInstruction {
+ public:
+ TX_DECL_TXINSTRUCTION
+};
+
+class txGoTo : public txInstruction {
+ public:
+ explicit txGoTo(txInstruction* aTarget);
+
+ TX_DECL_TXINSTRUCTION
+
+ txInstruction* mTarget;
+};
+
+class txInsertAttrSet : public txInstruction {
+ public:
+ explicit txInsertAttrSet(const txExpandedName& aName);
+
+ TX_DECL_TXINSTRUCTION
+
+ txExpandedName mName;
+};
+
+class txLoopNodeSet : public txInstruction {
+ public:
+ explicit txLoopNodeSet(txInstruction* aTarget);
+
+ TX_DECL_TXINSTRUCTION
+
+ txInstruction* mTarget;
+};
+
+class txLREAttribute : public txInstruction {
+ public:
+ txLREAttribute(int32_t aNamespaceID, nsAtom* aLocalName, nsAtom* aPrefix,
+ mozilla::UniquePtr<Expr>&& aValue);
+
+ TX_DECL_TXINSTRUCTION
+
+ int32_t mNamespaceID;
+ RefPtr<nsAtom> mLocalName;
+ RefPtr<nsAtom> mLowercaseLocalName;
+ RefPtr<nsAtom> mPrefix;
+ mozilla::UniquePtr<Expr> mValue;
+};
+
+class txMessage : public txInstruction {
+ public:
+ explicit txMessage(bool aTerminate);
+
+ TX_DECL_TXINSTRUCTION
+
+ bool mTerminate;
+};
+
+class txNumber : public txInstruction {
+ public:
+ txNumber(txXSLTNumber::LevelType aLevel,
+ mozilla::UniquePtr<txPattern>&& aCount,
+ mozilla::UniquePtr<txPattern>&& aFrom,
+ mozilla::UniquePtr<Expr>&& aValue,
+ mozilla::UniquePtr<Expr>&& aFormat,
+ mozilla::UniquePtr<Expr>&& aGroupingSeparator,
+ mozilla::UniquePtr<Expr>&& aGroupingSize);
+
+ TX_DECL_TXINSTRUCTION
+
+ txXSLTNumber::LevelType mLevel;
+ mozilla::UniquePtr<txPattern> mCount;
+ mozilla::UniquePtr<txPattern> mFrom;
+ mozilla::UniquePtr<Expr> mValue;
+ mozilla::UniquePtr<Expr> mFormat;
+ mozilla::UniquePtr<Expr> mGroupingSeparator;
+ mozilla::UniquePtr<Expr> mGroupingSize;
+};
+
+class txPopParams : public txInstruction {
+ public:
+ TX_DECL_TXINSTRUCTION
+};
+
+class txProcessingInstruction : public txInstruction {
+ public:
+ explicit txProcessingInstruction(mozilla::UniquePtr<Expr>&& aName);
+
+ TX_DECL_TXINSTRUCTION
+
+ mozilla::UniquePtr<Expr> mName;
+};
+
+class txPushNewContext : public txInstruction {
+ public:
+ explicit txPushNewContext(mozilla::UniquePtr<Expr>&& aSelect);
+ ~txPushNewContext();
+
+ TX_DECL_TXINSTRUCTION
+
+ void addSort(mozilla::UniquePtr<Expr>&& aSelectExpr,
+ mozilla::UniquePtr<Expr>&& aLangExpr,
+ mozilla::UniquePtr<Expr>&& aDataTypeExpr,
+ mozilla::UniquePtr<Expr>&& aOrderExpr,
+ mozilla::UniquePtr<Expr>&& aCaseOrderExpr);
+
+ struct SortKey {
+ mozilla::UniquePtr<Expr> mSelectExpr;
+ mozilla::UniquePtr<Expr> mLangExpr;
+ mozilla::UniquePtr<Expr> mDataTypeExpr;
+ mozilla::UniquePtr<Expr> mOrderExpr;
+ mozilla::UniquePtr<Expr> mCaseOrderExpr;
+ };
+
+ nsTArray<SortKey> mSortKeys;
+ mozilla::UniquePtr<Expr> mSelect;
+ txInstruction* mBailTarget;
+};
+
+class txPushNullTemplateRule : public txInstruction {
+ public:
+ TX_DECL_TXINSTRUCTION
+};
+
+class txPushParams : public txInstruction {
+ public:
+ TX_DECL_TXINSTRUCTION
+};
+
+class txPushRTFHandler : public txInstruction {
+ public:
+ TX_DECL_TXINSTRUCTION
+};
+
+class txPushStringHandler : public txInstruction {
+ public:
+ explicit txPushStringHandler(bool aOnlyText);
+
+ TX_DECL_TXINSTRUCTION
+
+ bool mOnlyText;
+};
+
+class txRemoveVariable : public txInstruction {
+ public:
+ explicit txRemoveVariable(const txExpandedName& aName);
+
+ TX_DECL_TXINSTRUCTION
+
+ txExpandedName mName;
+};
+
+class txReturn : public txInstruction {
+ public:
+ TX_DECL_TXINSTRUCTION
+};
+
+class txSetParam : public txInstruction {
+ public:
+ txSetParam(const txExpandedName& aName, mozilla::UniquePtr<Expr>&& aValue);
+
+ TX_DECL_TXINSTRUCTION
+
+ txExpandedName mName;
+ mozilla::UniquePtr<Expr> mValue;
+};
+
+class txSetVariable : public txInstruction {
+ public:
+ txSetVariable(const txExpandedName& aName, mozilla::UniquePtr<Expr>&& aValue);
+
+ TX_DECL_TXINSTRUCTION
+
+ txExpandedName mName;
+ mozilla::UniquePtr<Expr> mValue;
+};
+
+class txStartElement : public txInstruction {
+ public:
+ txStartElement(mozilla::UniquePtr<Expr>&& aName,
+ mozilla::UniquePtr<Expr>&& aNamespace,
+ txNamespaceMap* aMappings);
+
+ TX_DECL_TXINSTRUCTION
+
+ mozilla::UniquePtr<Expr> mName;
+ mozilla::UniquePtr<Expr> mNamespace;
+ RefPtr<txNamespaceMap> mMappings;
+};
+
+class txStartLREElement : public txInstruction {
+ public:
+ txStartLREElement(int32_t aNamespaceID, nsAtom* aLocalName, nsAtom* aPrefix);
+
+ TX_DECL_TXINSTRUCTION
+
+ int32_t mNamespaceID;
+ RefPtr<nsAtom> mLocalName;
+ RefPtr<nsAtom> mLowercaseLocalName;
+ RefPtr<nsAtom> mPrefix;
+};
+
+class txText : public txInstruction {
+ public:
+ txText(const nsAString& aStr, bool aDOE);
+
+ TX_DECL_TXINSTRUCTION
+
+ nsString mStr;
+ bool mDOE;
+};
+
+class txValueOf : public txInstruction {
+ public:
+ txValueOf(mozilla::UniquePtr<Expr>&& aExpr, bool aDOE);
+
+ TX_DECL_TXINSTRUCTION
+
+ mozilla::UniquePtr<Expr> mExpr;
+ bool mDOE;
+};
+
+#endif // TRANSFRMX_TXINSTRUCTIONS_H
diff --git a/dom/xslt/xslt/txKey.h b/dom/xslt/xslt/txKey.h
new file mode 100644
index 0000000000..e3bf56ebaa
--- /dev/null
+++ b/dom/xslt/xslt/txKey.h
@@ -0,0 +1,186 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef txKey_h__
+#define txKey_h__
+
+#include "nsTHashtable.h"
+#include "txExpandedNameMap.h"
+#include "txList.h"
+#include "txNodeSet.h"
+#include "txXSLTPatterns.h"
+#include "txXMLUtils.h"
+
+class txPattern;
+class Expr;
+class txExecutionState;
+
+class txKeyValueHashKey {
+ public:
+ txKeyValueHashKey(const txExpandedName& aKeyName, int32_t aRootIdentifier,
+ const nsAString& aKeyValue)
+ : mKeyName(aKeyName),
+ mKeyValue(aKeyValue),
+ mRootIdentifier(aRootIdentifier) {}
+
+ txExpandedName mKeyName;
+ nsString mKeyValue;
+ int32_t mRootIdentifier;
+};
+
+struct txKeyValueHashEntry : public PLDHashEntryHdr {
+ public:
+ using KeyType = const txKeyValueHashKey&;
+ using KeyTypePointer = const txKeyValueHashKey*;
+
+ explicit txKeyValueHashEntry(KeyTypePointer aKey)
+ : mKey(*aKey), mNodeSet(new txNodeSet(nullptr)) {}
+
+ txKeyValueHashEntry(const txKeyValueHashEntry& entry)
+ : mKey(entry.mKey), mNodeSet(entry.mNodeSet) {}
+
+ bool KeyEquals(KeyTypePointer aKey) const;
+
+ static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
+
+ static PLDHashNumber HashKey(KeyTypePointer aKey);
+
+ enum { ALLOW_MEMMOVE = true };
+
+ txKeyValueHashKey mKey;
+ RefPtr<txNodeSet> mNodeSet;
+};
+
+using txKeyValueHash = nsTHashtable<txKeyValueHashEntry>;
+
+class txIndexedKeyHashKey {
+ public:
+ txIndexedKeyHashKey(txExpandedName aKeyName, int32_t aRootIdentifier)
+ : mKeyName(aKeyName), mRootIdentifier(aRootIdentifier) {}
+
+ txExpandedName mKeyName;
+ int32_t mRootIdentifier;
+};
+
+struct txIndexedKeyHashEntry : public PLDHashEntryHdr {
+ public:
+ using KeyType = const txIndexedKeyHashKey&;
+ using KeyTypePointer = const txIndexedKeyHashKey*;
+
+ explicit txIndexedKeyHashEntry(KeyTypePointer aKey)
+ : mKey(*aKey), mIndexed(false) {}
+
+ txIndexedKeyHashEntry(const txIndexedKeyHashEntry& entry)
+ : mKey(entry.mKey), mIndexed(entry.mIndexed) {}
+
+ bool KeyEquals(KeyTypePointer aKey) const;
+
+ static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
+
+ static PLDHashNumber HashKey(KeyTypePointer aKey);
+
+ enum { ALLOW_MEMMOVE = true };
+
+ txIndexedKeyHashKey mKey;
+ bool mIndexed;
+};
+
+using txIndexedKeyHash = nsTHashtable<txIndexedKeyHashEntry>;
+
+/**
+ * Class holding all <xsl:key>s of a particular expanded name in the
+ * stylesheet.
+ */
+class txXSLKey {
+ public:
+ explicit txXSLKey(const txExpandedName& aName) : mName(aName) {}
+
+ /**
+ * Adds a match/use pair.
+ * @param aMatch match-pattern
+ * @param aUse use-expression
+ * @return false if an error occurred, true otherwise
+ */
+ bool addKey(mozilla::UniquePtr<txPattern>&& aMatch,
+ mozilla::UniquePtr<Expr>&& aUse);
+
+ /**
+ * Indexes a subtree and adds it to the hash of key values
+ * @param aRoot Subtree root to index and add
+ * @param aKeyValueHash Hash to add values to
+ * @param aEs txExecutionState to use for XPath evaluation
+ */
+ nsresult indexSubtreeRoot(const txXPathNode& aRoot,
+ txKeyValueHash& aKeyValueHash,
+ txExecutionState& aEs);
+
+ private:
+ /**
+ * Recursively searches a node, its attributes and its subtree for
+ * nodes matching any of the keys match-patterns.
+ * @param aNode Node to search
+ * @param aKey Key to use when adding into the hash
+ * @param aKeyValueHash Hash to add values to
+ * @param aEs txExecutionState to use for XPath evaluation
+ */
+ nsresult indexTree(const txXPathNode& aNode, txKeyValueHashKey& aKey,
+ txKeyValueHash& aKeyValueHash, txExecutionState& aEs);
+
+ /**
+ * Tests one node if it matches any of the keys match-patterns. If
+ * the node matches its values are added to the index.
+ * @param aNode Node to test
+ * @param aKey Key to use when adding into the hash
+ * @param aKeyValueHash Hash to add values to
+ * @param aEs txExecutionState to use for XPath evaluation
+ */
+ nsresult testNode(const txXPathNode& aNode, txKeyValueHashKey& aKey,
+ txKeyValueHash& aKeyValueHash, txExecutionState& aEs);
+
+ /**
+ * represents one match/use pair
+ */
+ struct Key {
+ mozilla::UniquePtr<txPattern> matchPattern;
+ mozilla::UniquePtr<Expr> useExpr;
+ };
+
+ /**
+ * List of all match/use pairs. The items as |Key|s
+ */
+ nsTArray<Key> mKeys;
+
+ /**
+ * Name of this key
+ */
+ txExpandedName mName;
+};
+
+class txKeyHash {
+ public:
+ explicit txKeyHash(const txOwningExpandedNameMap<txXSLKey>& aKeys)
+ : mKeyValues(4), mIndexedKeys(1), mKeys(aKeys) {}
+
+ nsresult init();
+
+ nsresult getKeyNodes(const txExpandedName& aKeyName, const txXPathNode& aRoot,
+ const nsAString& aKeyValue, bool aIndexIfNotFound,
+ txExecutionState& aEs, txNodeSet** aResult);
+
+ private:
+ // Hash of all indexed key-values
+ txKeyValueHash mKeyValues;
+
+ // Hash showing which keys+roots has been indexed
+ txIndexedKeyHash mIndexedKeys;
+
+ // Map of txXSLKeys
+ const txOwningExpandedNameMap<txXSLKey>& mKeys;
+
+ // Empty nodeset returned if no key is found
+ RefPtr<txNodeSet> mEmptyNodeSet;
+};
+
+#endif // txKey_h__
diff --git a/dom/xslt/xslt/txKeyFunctionCall.cpp b/dom/xslt/xslt/txKeyFunctionCall.cpp
new file mode 100644
index 0000000000..9219b335ca
--- /dev/null
+++ b/dom/xslt/xslt/txKeyFunctionCall.cpp
@@ -0,0 +1,345 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <utility>
+
+#include "mozilla/HashFunctions.h"
+#include "nsGkAtoms.h"
+#include "nsReadableUtils.h"
+#include "txExecutionState.h"
+#include "txKey.h"
+#include "txNamespaceMap.h"
+#include "txSingleNodeContext.h"
+#include "txXSLTFunctions.h"
+#include "txXSLTPatterns.h"
+
+using namespace mozilla;
+
+/*
+ * txKeyFunctionCall
+ * A representation of the XSLT additional function: key()
+ */
+
+/*
+ * Creates a new key function call
+ */
+txKeyFunctionCall::txKeyFunctionCall(txNamespaceMap* aMappings)
+ : mMappings(aMappings) {}
+
+/*
+ * Evaluates a key() xslt-function call. First argument is name of key
+ * to use, second argument is value to look up.
+ * @param aContext the context node for evaluation of this Expr
+ * @param aCs the ContextState containing the stack information needed
+ * for evaluation
+ * @return the result of the evaluation
+ */
+nsresult txKeyFunctionCall::evaluate(txIEvalContext* aContext,
+ txAExprResult** aResult) {
+ if (!aContext || !requireParams(2, 2, aContext))
+ return NS_ERROR_XPATH_BAD_ARGUMENT_COUNT;
+
+ txExecutionState* es =
+ static_cast<txExecutionState*>(aContext->getPrivateContext());
+
+ nsAutoString keyQName;
+ nsresult rv = mParams[0]->evaluateToString(aContext, keyQName);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ txExpandedName keyName;
+ rv = keyName.init(keyQName, mMappings, false);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ RefPtr<txAExprResult> exprResult;
+ rv = mParams[1]->evaluate(aContext, getter_AddRefs(exprResult));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ txXPathTreeWalker walker(aContext->getContextNode());
+ walker.moveToRoot();
+
+ RefPtr<txNodeSet> res;
+ txNodeSet* nodeSet;
+ if (exprResult->getResultType() == txAExprResult::NODESET &&
+ (nodeSet =
+ static_cast<txNodeSet*>(static_cast<txAExprResult*>(exprResult)))
+ ->size() > 1) {
+ rv = aContext->recycler()->getNodeSet(getter_AddRefs(res));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ int32_t i;
+ for (i = 0; i < nodeSet->size(); ++i) {
+ nsAutoString val;
+ txXPathNodeUtils::appendNodeValue(nodeSet->get(i), val);
+
+ RefPtr<txNodeSet> nodes;
+ rv = es->getKeyNodes(keyName, walker.getCurrentPosition(), val, i == 0,
+ getter_AddRefs(nodes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ res->add(*nodes);
+ }
+ } else {
+ nsAutoString val;
+ exprResult->stringValue(val);
+ rv = es->getKeyNodes(keyName, walker.getCurrentPosition(), val, true,
+ getter_AddRefs(res));
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ *aResult = res;
+ NS_ADDREF(*aResult);
+
+ return NS_OK;
+}
+
+Expr::ResultType txKeyFunctionCall::getReturnType() { return NODESET_RESULT; }
+
+bool txKeyFunctionCall::isSensitiveTo(ContextSensitivity aContext) {
+ return (aContext & NODE_CONTEXT) || argsSensitiveTo(aContext);
+}
+
+#ifdef TX_TO_STRING
+void txKeyFunctionCall::appendName(nsAString& aDest) {
+ aDest.Append(nsGkAtoms::key->GetUTF16String());
+}
+#endif
+
+/**
+ * Hash functions
+ */
+
+bool txKeyValueHashEntry::KeyEquals(KeyTypePointer aKey) const {
+ return mKey.mKeyName == aKey->mKeyName &&
+ mKey.mRootIdentifier == aKey->mRootIdentifier &&
+ mKey.mKeyValue.Equals(aKey->mKeyValue);
+}
+
+PLDHashNumber txKeyValueHashEntry::HashKey(KeyTypePointer aKey) {
+ const txKeyValueHashKey* key = static_cast<const txKeyValueHashKey*>(aKey);
+
+ return AddToHash(HashString(key->mKeyValue), key->mKeyName.mNamespaceID,
+ key->mRootIdentifier, key->mKeyName.mLocalName.get());
+}
+
+bool txIndexedKeyHashEntry::KeyEquals(KeyTypePointer aKey) const {
+ return mKey.mKeyName == aKey->mKeyName &&
+ mKey.mRootIdentifier == aKey->mRootIdentifier;
+}
+
+PLDHashNumber txIndexedKeyHashEntry::HashKey(KeyTypePointer aKey) {
+ const txIndexedKeyHashKey* key =
+ static_cast<const txIndexedKeyHashKey*>(aKey);
+ return HashGeneric(key->mKeyName.mNamespaceID, key->mRootIdentifier,
+ key->mKeyName.mLocalName.get());
+}
+
+/*
+ * Class managing XSLT-keys
+ */
+
+nsresult txKeyHash::getKeyNodes(const txExpandedName& aKeyName,
+ const txXPathNode& aRoot,
+ const nsAString& aKeyValue,
+ bool aIndexIfNotFound, txExecutionState& aEs,
+ txNodeSet** aResult) {
+ *aResult = nullptr;
+
+ int32_t identifier = txXPathNodeUtils::getUniqueIdentifier(aRoot);
+
+ txKeyValueHashKey valueKey(aKeyName, identifier, aKeyValue);
+ txKeyValueHashEntry* valueEntry = mKeyValues.GetEntry(valueKey);
+ if (valueEntry) {
+ *aResult = valueEntry->mNodeSet;
+ NS_ADDREF(*aResult);
+
+ return NS_OK;
+ }
+
+ // We didn't find a value. This could either mean that that key has no
+ // nodes with that value or that the key hasn't been indexed using this
+ // document.
+
+ if (!aIndexIfNotFound) {
+ // If aIndexIfNotFound is set then the caller knows this key is
+ // indexed, so don't bother investigating.
+ *aResult = mEmptyNodeSet;
+ NS_ADDREF(*aResult);
+
+ return NS_OK;
+ }
+
+ txIndexedKeyHashKey indexKey(aKeyName, identifier);
+ txIndexedKeyHashEntry* indexEntry = mIndexedKeys.PutEntry(indexKey);
+ NS_ENSURE_TRUE(indexEntry, NS_ERROR_OUT_OF_MEMORY);
+
+ if (indexEntry->mIndexed) {
+ // The key was indexed and apparently didn't contain this value so
+ // return the empty nodeset.
+ *aResult = mEmptyNodeSet;
+ NS_ADDREF(*aResult);
+
+ return NS_OK;
+ }
+
+ // The key needs to be indexed.
+ txXSLKey* xslKey = mKeys.get(aKeyName);
+ if (!xslKey) {
+ // The key didn't exist, so bail.
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ nsresult rv = xslKey->indexSubtreeRoot(aRoot, mKeyValues, aEs);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ indexEntry->mIndexed = true;
+
+ // Now that the key is indexed we can get its value.
+ valueEntry = mKeyValues.GetEntry(valueKey);
+ if (valueEntry) {
+ *aResult = valueEntry->mNodeSet;
+ NS_ADDREF(*aResult);
+ } else {
+ *aResult = mEmptyNodeSet;
+ NS_ADDREF(*aResult);
+ }
+
+ return NS_OK;
+}
+
+nsresult txKeyHash::init() {
+ mEmptyNodeSet = new txNodeSet(nullptr);
+
+ return NS_OK;
+}
+
+/**
+ * Adds a match/use pair.
+ * @param aMatch match-pattern
+ * @param aUse use-expression
+ * @return false if an error occurred, true otherwise
+ */
+bool txXSLKey::addKey(UniquePtr<txPattern>&& aMatch, UniquePtr<Expr>&& aUse) {
+ if (!aMatch || !aUse) return false;
+
+ Key* key = mKeys.AppendElement();
+ if (!key) return false;
+
+ key->matchPattern = std::move(aMatch);
+ key->useExpr = std::move(aUse);
+
+ return true;
+}
+
+/**
+ * Indexes a document and adds it to the hash of key values
+ * @param aRoot Subtree root to index and add
+ * @param aKeyValueHash Hash to add values to
+ * @param aEs txExecutionState to use for XPath evaluation
+ */
+nsresult txXSLKey::indexSubtreeRoot(const txXPathNode& aRoot,
+ txKeyValueHash& aKeyValueHash,
+ txExecutionState& aEs) {
+ txKeyValueHashKey key(mName, txXPathNodeUtils::getUniqueIdentifier(aRoot),
+ u""_ns);
+ return indexTree(aRoot, key, aKeyValueHash, aEs);
+}
+
+/**
+ * Recursively searches a node, its attributes and its subtree for
+ * nodes matching any of the keys match-patterns.
+ * @param aNode Node to search
+ * @param aKey Key to use when adding into the hash
+ * @param aKeyValueHash Hash to add values to
+ * @param aEs txExecutionState to use for XPath evaluation
+ */
+nsresult txXSLKey::indexTree(const txXPathNode& aNode, txKeyValueHashKey& aKey,
+ txKeyValueHash& aKeyValueHash,
+ txExecutionState& aEs) {
+ nsresult rv = testNode(aNode, aKey, aKeyValueHash, aEs);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // check if the node's attributes match
+ txXPathTreeWalker walker(aNode);
+ if (walker.moveToFirstAttribute()) {
+ do {
+ rv = testNode(walker.getCurrentPosition(), aKey, aKeyValueHash, aEs);
+ NS_ENSURE_SUCCESS(rv, rv);
+ } while (walker.moveToNextAttribute());
+ walker.moveToParent();
+ }
+
+ // check if the node's descendants match
+ if (walker.moveToFirstChild()) {
+ do {
+ rv = indexTree(walker.getCurrentPosition(), aKey, aKeyValueHash, aEs);
+ NS_ENSURE_SUCCESS(rv, rv);
+ } while (walker.moveToNextSibling());
+ }
+
+ return NS_OK;
+}
+
+/**
+ * Tests one node if it matches any of the keys match-patterns. If
+ * the node matches its values are added to the index.
+ * @param aNode Node to test
+ * @param aKey Key to use when adding into the hash
+ * @param aKeyValueHash Hash to add values to
+ * @param aEs txExecutionState to use for XPath evaluation
+ */
+nsresult txXSLKey::testNode(const txXPathNode& aNode, txKeyValueHashKey& aKey,
+ txKeyValueHash& aKeyValueHash,
+ txExecutionState& aEs) {
+ nsAutoString val;
+ uint32_t currKey, numKeys = mKeys.Length();
+ for (currKey = 0; currKey < numKeys; ++currKey) {
+ bool matched;
+ nsresult rv = mKeys[currKey].matchPattern->matches(aNode, &aEs, matched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (matched) {
+ aEs.pushEvalContext(new txSingleNodeContext(aNode, &aEs));
+
+ RefPtr<txAExprResult> exprResult;
+ nsresult rv = mKeys[currKey].useExpr->evaluate(
+ aEs.getEvalContext(), getter_AddRefs(exprResult));
+
+ delete aEs.popEvalContext();
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (exprResult->getResultType() == txAExprResult::NODESET) {
+ txNodeSet* res =
+ static_cast<txNodeSet*>(static_cast<txAExprResult*>(exprResult));
+ int32_t i;
+ for (i = 0; i < res->size(); ++i) {
+ val.Truncate();
+ txXPathNodeUtils::appendNodeValue(res->get(i), val);
+
+ aKey.mKeyValue.Assign(val);
+ txKeyValueHashEntry* entry = aKeyValueHash.PutEntry(aKey);
+ NS_ENSURE_TRUE(entry && entry->mNodeSet, NS_ERROR_OUT_OF_MEMORY);
+
+ if (entry->mNodeSet->isEmpty() ||
+ entry->mNodeSet->get(entry->mNodeSet->size() - 1) != aNode) {
+ entry->mNodeSet->append(aNode);
+ }
+ }
+ } else {
+ exprResult->stringValue(val);
+
+ aKey.mKeyValue.Assign(val);
+ txKeyValueHashEntry* entry = aKeyValueHash.PutEntry(aKey);
+ NS_ENSURE_TRUE(entry && entry->mNodeSet, NS_ERROR_OUT_OF_MEMORY);
+
+ if (entry->mNodeSet->isEmpty() ||
+ entry->mNodeSet->get(entry->mNodeSet->size() - 1) != aNode) {
+ entry->mNodeSet->append(aNode);
+ }
+ }
+ }
+ }
+
+ return NS_OK;
+}
diff --git a/dom/xslt/xslt/txMozillaStylesheetCompiler.cpp b/dom/xslt/xslt/txMozillaStylesheetCompiler.cpp
new file mode 100644
index 0000000000..252347492d
--- /dev/null
+++ b/dom/xslt/xslt/txMozillaStylesheetCompiler.cpp
@@ -0,0 +1,622 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsIAuthPrompt.h"
+#include "mozilla/dom/Document.h"
+#include "nsIExpatSink.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsILoadGroup.h"
+#include "nsParser.h"
+#include "nsCharsetSource.h"
+#include "nsIRequestObserver.h"
+#include "nsContentPolicyUtils.h"
+#include "nsIStreamConverterService.h"
+#include "nsSyncLoadService.h"
+#include "nsIHttpChannel.h"
+#include "nsIURI.h"
+#include "nsIPrincipal.h"
+#include "nsIWindowWatcher.h"
+#include "nsIXMLContentSink.h"
+#include "nsMimeTypes.h"
+#include "nsNetUtil.h"
+#include "nsGkAtoms.h"
+#include "txLog.h"
+#include "txMozillaXSLTProcessor.h"
+#include "txStylesheetCompiler.h"
+#include "txXMLUtils.h"
+#include "nsAttrName.h"
+#include "nsComponentManagerUtils.h"
+#include "nsIScriptError.h"
+#include "nsError.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/Text.h"
+#include "mozilla/Encoding.h"
+#include "mozilla/UniquePtr.h"
+#include "ReferrerInfo.h"
+
+using namespace mozilla;
+using mozilla::dom::Document;
+using mozilla::dom::ReferrerPolicy;
+
+static void getSpec(nsIChannel* aChannel, nsAString& aSpec) {
+ if (!aChannel) {
+ return;
+ }
+
+ nsCOMPtr<nsIURI> uri;
+ aChannel->GetOriginalURI(getter_AddRefs(uri));
+ if (!uri) {
+ return;
+ }
+
+ nsAutoCString spec;
+ uri->GetSpec(spec);
+ AppendUTF8toUTF16(spec, aSpec);
+}
+
+class txStylesheetSink final : public nsIXMLContentSink,
+ public nsIExpatSink,
+ public nsIStreamListener,
+ public nsIInterfaceRequestor {
+ public:
+ txStylesheetSink(txStylesheetCompiler* aCompiler, nsParser* aParser);
+
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIEXPATSINK
+ NS_DECL_NSISTREAMLISTENER
+ NS_DECL_NSIREQUESTOBSERVER
+ NS_DECL_NSIINTERFACEREQUESTOR
+
+ // nsIContentSink
+ NS_IMETHOD WillParse(void) override { return NS_OK; }
+ NS_IMETHOD DidBuildModel(bool aTerminated) override;
+ NS_IMETHOD WillInterrupt(void) override { return NS_OK; }
+ void WillResume() override {}
+ NS_IMETHOD SetParser(nsParserBase* aParser) override { return NS_OK; }
+ virtual void FlushPendingNotifications(mozilla::FlushType aType) override {}
+ virtual void SetDocumentCharset(NotNull<const Encoding*> aEncoding) override {
+ }
+ virtual nsISupports* GetTarget() override { return nullptr; }
+
+ private:
+ RefPtr<txStylesheetCompiler> mCompiler;
+ nsCOMPtr<nsIStreamListener> mListener;
+ RefPtr<nsParser> mParser;
+ bool mCheckedForXML;
+
+ protected:
+ ~txStylesheetSink() = default;
+
+ // This exists solely to suppress a warning from nsDerivedSafe
+ txStylesheetSink();
+};
+
+txStylesheetSink::txStylesheetSink(txStylesheetCompiler* aCompiler,
+ nsParser* aParser)
+ : mCompiler(aCompiler),
+ mListener(aParser),
+ mParser(aParser),
+ mCheckedForXML(false) {}
+
+NS_IMPL_ISUPPORTS(txStylesheetSink, nsIXMLContentSink, nsIContentSink,
+ nsIExpatSink, nsIStreamListener, nsIRequestObserver,
+ nsIInterfaceRequestor)
+
+NS_IMETHODIMP
+txStylesheetSink::HandleStartElement(const char16_t* aName,
+ const char16_t** aAtts,
+ uint32_t aAttsCount, uint32_t aLineNumber,
+ uint32_t aColumnNumber) {
+ MOZ_ASSERT(aAttsCount % 2 == 0, "incorrect aAttsCount");
+
+ nsresult rv = mCompiler->startElement(aName, aAtts, aAttsCount / 2);
+ if (NS_FAILED(rv)) {
+ mCompiler->cancel(rv);
+
+ return rv;
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+txStylesheetSink::HandleEndElement(const char16_t* aName) {
+ nsresult rv = mCompiler->endElement();
+ if (NS_FAILED(rv)) {
+ mCompiler->cancel(rv);
+
+ return rv;
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+txStylesheetSink::HandleComment(const char16_t* aName) { return NS_OK; }
+
+NS_IMETHODIMP
+txStylesheetSink::HandleCDataSection(const char16_t* aData, uint32_t aLength) {
+ return HandleCharacterData(aData, aLength);
+}
+
+NS_IMETHODIMP
+txStylesheetSink::HandleDoctypeDecl(const nsAString& aSubset,
+ const nsAString& aName,
+ const nsAString& aSystemId,
+ const nsAString& aPublicId,
+ nsISupports* aCatalogData) {
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+txStylesheetSink::HandleCharacterData(const char16_t* aData, uint32_t aLength) {
+ nsresult rv = mCompiler->characters(Substring(aData, aData + aLength));
+ if (NS_FAILED(rv)) {
+ mCompiler->cancel(rv);
+ return rv;
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+txStylesheetSink::HandleProcessingInstruction(const char16_t* aTarget,
+ const char16_t* aData) {
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+txStylesheetSink::HandleXMLDeclaration(const char16_t* aVersion,
+ const char16_t* aEncoding,
+ int32_t aStandalone) {
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+txStylesheetSink::ReportError(const char16_t* aErrorText,
+ const char16_t* aSourceText,
+ nsIScriptError* aError, bool* _retval) {
+ MOZ_ASSERT(aError && aSourceText && aErrorText, "Check arguments!!!");
+
+ // The expat driver should report the error.
+ *_retval = true;
+
+ mCompiler->cancel(NS_ERROR_FAILURE, aErrorText, aSourceText);
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+txStylesheetSink::DidBuildModel(bool aTerminated) {
+ return mCompiler->doneLoading();
+}
+
+NS_IMETHODIMP
+txStylesheetSink::OnDataAvailable(nsIRequest* aRequest,
+ nsIInputStream* aInputStream,
+ uint64_t aOffset, uint32_t aCount) {
+ if (!mCheckedForXML) {
+ Maybe<bool> isForXML = mParser->IsForParsingXML();
+ mCheckedForXML = isForXML.isSome();
+ if (mCheckedForXML && !isForXML.value()) {
+ nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);
+ nsAutoString spec;
+ getSpec(channel, spec);
+ mCompiler->cancel(NS_ERROR_XSLT_WRONG_MIME_TYPE, nullptr, spec.get());
+
+ return NS_ERROR_XSLT_WRONG_MIME_TYPE;
+ }
+ }
+
+ return mListener->OnDataAvailable(aRequest, aInputStream, aOffset, aCount);
+}
+
+NS_IMETHODIMP
+txStylesheetSink::OnStartRequest(nsIRequest* aRequest) {
+ int32_t charsetSource = kCharsetFromDocTypeDefault;
+
+ nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);
+
+ // check channel's charset...
+ const Encoding* encoding = nullptr;
+ nsAutoCString charsetVal;
+ if (NS_SUCCEEDED(channel->GetContentCharset(charsetVal))) {
+ encoding = Encoding::ForLabel(charsetVal);
+ if (encoding) {
+ charsetSource = kCharsetFromChannel;
+ }
+ }
+
+ if (!encoding) {
+ encoding = UTF_8_ENCODING;
+ }
+
+ mParser->SetDocumentCharset(WrapNotNull(encoding), charsetSource, false);
+
+ nsAutoCString contentType;
+ channel->GetContentType(contentType);
+
+ // Time to sniff! Note: this should go away once file channels do
+ // sniffing themselves.
+ nsCOMPtr<nsIURI> uri;
+ channel->GetURI(getter_AddRefs(uri));
+ if (uri->SchemeIs("file") &&
+ contentType.EqualsLiteral(UNKNOWN_CONTENT_TYPE)) {
+ nsresult rv;
+ nsCOMPtr<nsIStreamConverterService> serv =
+ do_GetService("@mozilla.org/streamConverters;1", &rv);
+ if (NS_SUCCEEDED(rv)) {
+ nsCOMPtr<nsIStreamListener> converter;
+ rv = serv->AsyncConvertData(UNKNOWN_CONTENT_TYPE, "*/*", mListener,
+ NS_ISUPPORTS_CAST(nsIParser*, mParser),
+ getter_AddRefs(converter));
+ if (NS_SUCCEEDED(rv)) {
+ mListener = converter;
+ }
+ }
+ }
+
+ return mListener->OnStartRequest(aRequest);
+}
+
+NS_IMETHODIMP
+txStylesheetSink::OnStopRequest(nsIRequest* aRequest, nsresult aStatusCode) {
+ bool success = true;
+
+ nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(aRequest);
+ if (httpChannel) {
+ Unused << httpChannel->GetRequestSucceeded(&success);
+ }
+
+ nsresult result = aStatusCode;
+ if (!success) {
+ // XXX We sometimes want to use aStatusCode here, but the parser resets
+ // it to NS_ERROR_NOINTERFACE because we don't implement
+ // nsIHTMLContentSink.
+ result = NS_ERROR_XSLT_NETWORK_ERROR;
+ } else if (!mCheckedForXML) {
+ Maybe<bool> isForXML = mParser->IsForParsingXML();
+ if (isForXML.isSome() && !isForXML.value()) {
+ result = NS_ERROR_XSLT_WRONG_MIME_TYPE;
+ }
+ }
+
+ if (NS_FAILED(result)) {
+ nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);
+ nsAutoString spec;
+ getSpec(channel, spec);
+ mCompiler->cancel(result, nullptr, spec.get());
+ }
+
+ nsresult rv = mListener->OnStopRequest(aRequest, aStatusCode);
+ mListener = nullptr;
+ mParser = nullptr;
+ return rv;
+}
+
+NS_IMETHODIMP
+txStylesheetSink::GetInterface(const nsIID& aIID, void** aResult) {
+ if (aIID.Equals(NS_GET_IID(nsIAuthPrompt))) {
+ NS_ENSURE_ARG(aResult);
+ *aResult = nullptr;
+
+ nsresult rv;
+ nsCOMPtr<nsIWindowWatcher> wwatcher =
+ do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ nsCOMPtr<nsIAuthPrompt> prompt;
+ rv = wwatcher->GetNewAuthPrompter(nullptr, getter_AddRefs(prompt));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ prompt.forget(aResult);
+
+ return NS_OK;
+ }
+
+ return NS_ERROR_NO_INTERFACE;
+}
+
+class txCompileObserver final : public txACompileObserver {
+ public:
+ txCompileObserver(txMozillaXSLTProcessor* aProcessor,
+ Document* aLoaderDocument);
+
+ TX_DECL_ACOMPILEOBSERVER
+ NS_INLINE_DECL_REFCOUNTING(txCompileObserver, override)
+
+ nsresult startLoad(nsIURI* aUri, txStylesheetCompiler* aCompiler,
+ nsIPrincipal* aSourcePrincipal,
+ ReferrerPolicy aReferrerPolicy);
+
+ private:
+ RefPtr<txMozillaXSLTProcessor> mProcessor;
+ nsCOMPtr<Document> mLoaderDocument;
+
+ // This exists solely to suppress a warning from nsDerivedSafe
+ txCompileObserver();
+
+ // Private destructor, to discourage deletion outside of Release():
+ ~txCompileObserver() = default;
+};
+
+txCompileObserver::txCompileObserver(txMozillaXSLTProcessor* aProcessor,
+ Document* aLoaderDocument)
+ : mProcessor(aProcessor), mLoaderDocument(aLoaderDocument) {}
+
+nsresult txCompileObserver::loadURI(const nsAString& aUri,
+ const nsAString& aReferrerUri,
+ ReferrerPolicy aReferrerPolicy,
+ txStylesheetCompiler* aCompiler) {
+ if (mProcessor->IsLoadDisabled()) {
+ return NS_ERROR_XSLT_LOAD_BLOCKED_ERROR;
+ }
+
+ nsCOMPtr<nsIURI> uri;
+ nsresult rv = NS_NewURI(getter_AddRefs(uri), aUri);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ nsCOMPtr<nsIURI> referrerUri;
+ rv = NS_NewURI(getter_AddRefs(referrerUri), aReferrerUri);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ OriginAttributes attrs;
+ nsCOMPtr<nsIPrincipal> referrerPrincipal =
+ BasePrincipal::CreateContentPrincipal(referrerUri, attrs);
+ NS_ENSURE_TRUE(referrerPrincipal, NS_ERROR_FAILURE);
+
+ return startLoad(uri, aCompiler, referrerPrincipal, aReferrerPolicy);
+}
+
+void txCompileObserver::onDoneCompiling(txStylesheetCompiler* aCompiler,
+ nsresult aResult,
+ const char16_t* aErrorText,
+ const char16_t* aParam) {
+ if (NS_SUCCEEDED(aResult)) {
+ mProcessor->setStylesheet(aCompiler->getStylesheet());
+ } else {
+ mProcessor->reportError(aResult, aErrorText, aParam);
+ }
+}
+
+nsresult txCompileObserver::startLoad(nsIURI* aUri,
+ txStylesheetCompiler* aCompiler,
+ nsIPrincipal* aReferrerPrincipal,
+ ReferrerPolicy aReferrerPolicy) {
+ nsCOMPtr<nsILoadGroup> loadGroup = mLoaderDocument->GetDocumentLoadGroup();
+ if (!loadGroup) {
+ return NS_ERROR_FAILURE;
+ }
+
+ nsCOMPtr<nsIChannel> channel;
+ nsresult rv = NS_NewChannelWithTriggeringPrincipal(
+ getter_AddRefs(channel), aUri, mLoaderDocument,
+ aReferrerPrincipal, // triggeringPrincipal
+ nsILoadInfo::SEC_REQUIRE_CORS_INHERITS_SEC_CONTEXT,
+ nsIContentPolicy::TYPE_XSLT,
+ nullptr, // aPerformanceStorage
+ loadGroup);
+
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ channel->SetContentType("text/xml"_ns);
+
+ nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(channel));
+ if (httpChannel) {
+ nsCOMPtr<nsIReferrerInfo> referrerInfo;
+ nsresult rv = aReferrerPrincipal->CreateReferrerInfo(
+ aReferrerPolicy, getter_AddRefs(referrerInfo));
+ if (NS_SUCCEEDED(rv)) {
+ rv = httpChannel->SetReferrerInfoWithoutClone(referrerInfo);
+ MOZ_ASSERT(NS_SUCCEEDED(rv));
+ }
+ }
+
+ RefPtr<nsParser> parser = new nsParser();
+ RefPtr<txStylesheetSink> sink = new txStylesheetSink(aCompiler, parser);
+
+ channel->SetNotificationCallbacks(sink);
+
+ parser->SetCommand(kLoadAsData);
+ parser->SetContentSink(sink);
+ parser->Parse(aUri);
+
+ return channel->AsyncOpen(sink);
+}
+
+nsresult TX_LoadSheet(nsIURI* aUri, txMozillaXSLTProcessor* aProcessor,
+ Document* aLoaderDocument,
+ ReferrerPolicy aReferrerPolicy) {
+ nsIPrincipal* principal = aLoaderDocument->NodePrincipal();
+
+ nsAutoCString spec;
+ aUri->GetSpec(spec);
+ MOZ_LOG(txLog::xslt, LogLevel::Info, ("TX_LoadSheet: %s\n", spec.get()));
+
+ RefPtr<txCompileObserver> observer =
+ new txCompileObserver(aProcessor, aLoaderDocument);
+
+ RefPtr<txStylesheetCompiler> compiler = new txStylesheetCompiler(
+ NS_ConvertUTF8toUTF16(spec), aReferrerPolicy, observer);
+
+ return observer->startLoad(aUri, compiler, principal, aReferrerPolicy);
+}
+
+/**
+ * handling DOM->txStylesheet
+ * Observer needs to do synchronous loads.
+ */
+static nsresult handleNode(nsINode* aNode, txStylesheetCompiler* aCompiler) {
+ nsresult rv = NS_OK;
+
+ if (aNode->IsElement()) {
+ dom::Element* element = aNode->AsElement();
+
+ uint32_t attsCount = element->GetAttrCount();
+ UniquePtr<txStylesheetAttr[]> atts;
+ if (attsCount > 0) {
+ atts = MakeUnique<txStylesheetAttr[]>(attsCount);
+ uint32_t counter;
+ for (counter = 0; counter < attsCount; ++counter) {
+ txStylesheetAttr& att = atts[counter];
+ const nsAttrName* name = element->GetAttrNameAt(counter);
+ att.mNamespaceID = name->NamespaceID();
+ att.mLocalName = name->LocalName();
+ att.mPrefix = name->GetPrefix();
+ element->GetAttr(att.mNamespaceID, att.mLocalName, att.mValue);
+ }
+ }
+
+ mozilla::dom::NodeInfo* ni = element->NodeInfo();
+
+ rv = aCompiler->startElement(ni->NamespaceID(), ni->NameAtom(),
+ ni->GetPrefixAtom(), atts.get(), attsCount);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // explicitly destroy the attrs here since we no longer need it
+ atts = nullptr;
+
+ for (nsIContent* child = element->GetFirstChild(); child;
+ child = child->GetNextSibling()) {
+ rv = handleNode(child, aCompiler);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ rv = aCompiler->endElement();
+ NS_ENSURE_SUCCESS(rv, rv);
+ } else if (dom::Text* text = aNode->GetAsText()) {
+ nsAutoString chars;
+ text->AppendTextTo(chars);
+ rv = aCompiler->characters(chars);
+ NS_ENSURE_SUCCESS(rv, rv);
+ } else if (aNode->IsDocument()) {
+ for (nsIContent* child = aNode->GetFirstChild(); child;
+ child = child->GetNextSibling()) {
+ rv = handleNode(child, aCompiler);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ }
+
+ return NS_OK;
+}
+
+class txSyncCompileObserver final : public txACompileObserver {
+ public:
+ explicit txSyncCompileObserver(txMozillaXSLTProcessor* aProcessor);
+
+ TX_DECL_ACOMPILEOBSERVER
+ NS_INLINE_DECL_REFCOUNTING(txSyncCompileObserver, override)
+
+ private:
+ // Private destructor, to discourage deletion outside of Release():
+ ~txSyncCompileObserver() = default;
+
+ RefPtr<txMozillaXSLTProcessor> mProcessor;
+};
+
+txSyncCompileObserver::txSyncCompileObserver(txMozillaXSLTProcessor* aProcessor)
+ : mProcessor(aProcessor) {}
+
+nsresult txSyncCompileObserver::loadURI(const nsAString& aUri,
+ const nsAString& aReferrerUri,
+ ReferrerPolicy aReferrerPolicy,
+ txStylesheetCompiler* aCompiler) {
+ if (mProcessor->IsLoadDisabled()) {
+ return NS_ERROR_XSLT_LOAD_BLOCKED_ERROR;
+ }
+
+ nsCOMPtr<nsIURI> uri;
+ nsresult rv = NS_NewURI(getter_AddRefs(uri), aUri);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ nsCOMPtr<nsIURI> referrerUri;
+ rv = NS_NewURI(getter_AddRefs(referrerUri), aReferrerUri);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ nsCOMPtr<nsIPrincipal> referrerPrincipal =
+ BasePrincipal::CreateContentPrincipal(referrerUri, OriginAttributes());
+ NS_ENSURE_TRUE(referrerPrincipal, NS_ERROR_FAILURE);
+
+ // This is probably called by js, a loadGroup for the channel doesn't
+ // make sense.
+ nsCOMPtr<nsINode> source;
+ if (mProcessor) {
+ source = mProcessor->GetSourceContentModel();
+ }
+ dom::nsAutoSyncOperation sync(source ? source->OwnerDoc() : nullptr,
+ dom::SyncOperationBehavior::eSuspendInput);
+ nsCOMPtr<Document> document;
+
+ rv = nsSyncLoadService::LoadDocument(
+ uri, nsIContentPolicy::TYPE_XSLT, referrerPrincipal,
+ nsILoadInfo::SEC_REQUIRE_CORS_INHERITS_SEC_CONTEXT, nullptr,
+ source ? source->OwnerDoc()->CookieJarSettings() : nullptr, false,
+ aReferrerPolicy, getter_AddRefs(document));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = handleNode(document, aCompiler);
+ if (NS_FAILED(rv)) {
+ nsAutoCString spec;
+ uri->GetSpec(spec);
+ aCompiler->cancel(rv, nullptr, NS_ConvertUTF8toUTF16(spec).get());
+ return rv;
+ }
+
+ rv = aCompiler->doneLoading();
+ return rv;
+}
+
+void txSyncCompileObserver::onDoneCompiling(txStylesheetCompiler* aCompiler,
+ nsresult aResult,
+ const char16_t* aErrorText,
+ const char16_t* aParam) {}
+
+nsresult TX_CompileStylesheet(nsINode* aNode,
+ txMozillaXSLTProcessor* aProcessor,
+ txStylesheet** aStylesheet) {
+ // If we move GetBaseURI to nsINode this can be simplified.
+ nsCOMPtr<Document> doc = aNode->OwnerDoc();
+
+ nsIURI* nodeBaseURI = aNode->GetBaseURI();
+ NS_ENSURE_TRUE(nodeBaseURI, NS_ERROR_FAILURE);
+
+ nsAutoCString spec;
+ nodeBaseURI->GetSpec(spec);
+ NS_ConvertUTF8toUTF16 baseURI(spec);
+
+ nsIURI* docUri = doc->GetDocumentURI();
+ NS_ENSURE_TRUE(docUri, NS_ERROR_FAILURE);
+
+ // We need to remove the ref, a URI with a ref would mean that we have an
+ // embedded stylesheet.
+ nsCOMPtr<nsIURI> uri;
+ NS_GetURIWithoutRef(docUri, getter_AddRefs(uri));
+ NS_ENSURE_TRUE(uri, NS_ERROR_FAILURE);
+
+ uri->GetSpec(spec);
+ NS_ConvertUTF8toUTF16 stylesheetURI(spec);
+
+ RefPtr<txSyncCompileObserver> obs = new txSyncCompileObserver(aProcessor);
+
+ RefPtr<txStylesheetCompiler> compiler =
+ new txStylesheetCompiler(stylesheetURI, doc->GetReferrerPolicy(), obs);
+
+ compiler->setBaseURI(baseURI);
+
+ nsresult rv = handleNode(aNode, compiler);
+ if (NS_FAILED(rv)) {
+ compiler->cancel(rv);
+ return rv;
+ }
+
+ rv = compiler->doneLoading();
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ *aStylesheet = compiler->getStylesheet();
+ NS_ADDREF(*aStylesheet);
+
+ return NS_OK;
+}
diff --git a/dom/xslt/xslt/txMozillaTextOutput.cpp b/dom/xslt/xslt/txMozillaTextOutput.cpp
new file mode 100644
index 0000000000..dbb9969eb2
--- /dev/null
+++ b/dom/xslt/xslt/txMozillaTextOutput.cpp
@@ -0,0 +1,250 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txMozillaTextOutput.h"
+#include "nsContentCID.h"
+#include "nsIContent.h"
+#include "mozilla/dom/Document.h"
+#include "nsIDocumentTransformer.h"
+#include "nsCharsetSource.h"
+#include "txURIUtils.h"
+#include "nsContentCreatorFunctions.h"
+#include "nsContentUtils.h"
+#include "nsGkAtoms.h"
+#include "mozilla/Encoding.h"
+#include "nsTextNode.h"
+#include "nsNameSpaceManager.h"
+#include "mozilla/dom/DocumentFragment.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+txMozillaTextOutput::txMozillaTextOutput(Document* aSourceDocument,
+ nsITransformObserver* aObserver)
+ : mSourceDocument(aSourceDocument),
+ mObserver(do_GetWeakReference(aObserver)),
+ mCreatedDocument(false) {
+ MOZ_COUNT_CTOR(txMozillaTextOutput);
+}
+
+txMozillaTextOutput::txMozillaTextOutput(DocumentFragment* aDest)
+ : mTextParent(aDest),
+ mDocument(mTextParent->OwnerDoc()),
+ mCreatedDocument(false) {
+ MOZ_COUNT_CTOR(txMozillaTextOutput);
+ mTextParent = aDest;
+ mDocument = mTextParent->OwnerDoc();
+}
+
+txMozillaTextOutput::~txMozillaTextOutput() {
+ MOZ_COUNT_DTOR(txMozillaTextOutput);
+}
+
+nsresult txMozillaTextOutput::attribute(nsAtom* aPrefix, nsAtom* aLocalName,
+ nsAtom* aLowercaseLocalName,
+ int32_t aNsID, const nsString& aValue) {
+ return NS_OK;
+}
+
+nsresult txMozillaTextOutput::attribute(nsAtom* aPrefix, const nsAString& aName,
+ const int32_t aNsID,
+ const nsString& aValue) {
+ return NS_OK;
+}
+
+nsresult txMozillaTextOutput::characters(const nsAString& aData, bool aDOE) {
+ mText.Append(aData);
+
+ return NS_OK;
+}
+
+nsresult txMozillaTextOutput::comment(const nsString& aData) { return NS_OK; }
+
+nsresult txMozillaTextOutput::endDocument(nsresult aResult) {
+ NS_ENSURE_TRUE(mDocument && mTextParent, NS_ERROR_FAILURE);
+
+ RefPtr<nsTextNode> text = new (mDocument->NodeInfoManager())
+ nsTextNode(mDocument->NodeInfoManager());
+
+ ErrorResult rv;
+ text->SetText(mText, false);
+ mTextParent->AppendChildTo(text, true, rv);
+ if (rv.Failed()) {
+ return rv.StealNSResult();
+ }
+
+ // This should really be handled by Document::EndLoad
+ if (mCreatedDocument) {
+ MOZ_ASSERT(mDocument->GetReadyStateEnum() == Document::READYSTATE_LOADING,
+ "Bad readyState");
+ } else {
+ MOZ_ASSERT(
+ mDocument->GetReadyStateEnum() == Document::READYSTATE_INTERACTIVE,
+ "Bad readyState");
+ }
+ mDocument->SetReadyStateInternal(Document::READYSTATE_INTERACTIVE);
+
+ if (NS_SUCCEEDED(aResult)) {
+ nsCOMPtr<nsITransformObserver> observer = do_QueryReferent(mObserver);
+ if (observer) {
+ observer->OnTransformDone(mSourceDocument, aResult, mDocument);
+ }
+ }
+
+ return NS_OK;
+}
+
+nsresult txMozillaTextOutput::endElement() { return NS_OK; }
+
+nsresult txMozillaTextOutput::processingInstruction(const nsString& aTarget,
+ const nsString& aData) {
+ return NS_OK;
+}
+
+nsresult txMozillaTextOutput::startDocument() { return NS_OK; }
+
+nsresult txMozillaTextOutput::createResultDocument(bool aLoadedAsData) {
+ /*
+ * Create an XHTML document to hold the text.
+ *
+ * <html>
+ * <head />
+ * <body>
+ * <pre id="transformiixResult"> * The text comes here * </pre>
+ * <body>
+ * </html>
+ *
+ * Except if we are transforming into a non-displayed document we create
+ * the following DOM
+ *
+ * <transformiix:result> * The text comes here * </transformiix:result>
+ */
+
+ // Create the document
+ nsresult rv = NS_NewXMLDocument(getter_AddRefs(mDocument), aLoadedAsData);
+ NS_ENSURE_SUCCESS(rv, rv);
+ mCreatedDocument = true;
+ // This should really be handled by Document::BeginLoad
+ MOZ_ASSERT(
+ mDocument->GetReadyStateEnum() == Document::READYSTATE_UNINITIALIZED,
+ "Bad readyState");
+ mDocument->SetReadyStateInternal(Document::READYSTATE_LOADING);
+ bool hasHadScriptObject = false;
+ nsIScriptGlobalObject* sgo =
+ mSourceDocument->GetScriptHandlingObject(hasHadScriptObject);
+ NS_ENSURE_STATE(sgo || !hasHadScriptObject);
+
+ NS_ASSERTION(mDocument, "Need document");
+
+ // Reset and set up document
+ URIUtils::ResetWithSource(mDocument, mSourceDocument);
+ // Only do this after resetting the document to ensure we have the
+ // correct principal.
+ mDocument->SetScriptHandlingObject(sgo);
+
+ // Set the charset
+ if (!mOutputFormat.mEncoding.IsEmpty()) {
+ const Encoding* encoding = Encoding::ForLabel(mOutputFormat.mEncoding);
+ if (encoding) {
+ mDocument->SetDocumentCharacterSetSource(kCharsetFromOtherComponent);
+ mDocument->SetDocumentCharacterSet(WrapNotNull(encoding));
+ }
+ }
+
+ // Notify the contentsink that the document is created
+ nsCOMPtr<nsITransformObserver> observer = do_QueryReferent(mObserver);
+ if (observer) {
+ rv = observer->OnDocumentCreated(mSourceDocument, mDocument);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ // Create the content
+
+ // When transforming into a non-displayed document (i.e. when there is no
+ // observer) we only create a transformiix:result root element.
+ if (!observer) {
+ int32_t namespaceID;
+ rv = nsNameSpaceManager::GetInstance()->RegisterNameSpace(
+ nsLiteralString(kTXNameSpaceURI), namespaceID);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ mTextParent =
+ mDocument->CreateElem(nsDependentAtomString(nsGkAtoms::result),
+ nsGkAtoms::transformiix, namespaceID);
+
+ ErrorResult error;
+ mDocument->AppendChildTo(mTextParent, true, error);
+ if (error.Failed()) {
+ return error.StealNSResult();
+ }
+ } else {
+ RefPtr<Element> html, head, body;
+ rv = createXHTMLElement(nsGkAtoms::html, getter_AddRefs(html));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = createXHTMLElement(nsGkAtoms::head, getter_AddRefs(head));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ ErrorResult error;
+ html->AppendChildTo(head, false, error);
+ if (error.Failed()) {
+ return error.StealNSResult();
+ }
+
+ rv = createXHTMLElement(nsGkAtoms::body, getter_AddRefs(body));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ html->AppendChildTo(body, false, error);
+ if (error.Failed()) {
+ return error.StealNSResult();
+ }
+
+ {
+ RefPtr<Element> textParent;
+ rv = createXHTMLElement(nsGkAtoms::pre, getter_AddRefs(textParent));
+ NS_ENSURE_SUCCESS(rv, rv);
+ mTextParent = std::move(textParent);
+ }
+
+ rv = mTextParent->AsElement()->SetAttr(kNameSpaceID_None, nsGkAtoms::id,
+ u"transformiixResult"_ns, false);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ body->AppendChildTo(mTextParent, false, error);
+ if (error.Failed()) {
+ return error.StealNSResult();
+ }
+
+ mDocument->AppendChildTo(html, true, error);
+ if (error.Failed()) {
+ return error.StealNSResult();
+ }
+ }
+
+ return NS_OK;
+}
+
+nsresult txMozillaTextOutput::startElement(nsAtom* aPrefix, nsAtom* aLocalName,
+ nsAtom* aLowercaseLocalName,
+ int32_t aNsID) {
+ return NS_OK;
+}
+
+nsresult txMozillaTextOutput::startElement(nsAtom* aPrefix,
+ const nsAString& aName,
+ const int32_t aNsID) {
+ return NS_OK;
+}
+
+void txMozillaTextOutput::getOutputDocument(Document** aDocument) {
+ NS_IF_ADDREF(*aDocument = mDocument);
+}
+
+nsresult txMozillaTextOutput::createXHTMLElement(nsAtom* aName,
+ Element** aResult) {
+ nsCOMPtr<Element> element = mDocument->CreateHTMLElement(aName);
+ element.forget(aResult);
+ return NS_OK;
+}
diff --git a/dom/xslt/xslt/txMozillaTextOutput.h b/dom/xslt/xslt/txMozillaTextOutput.h
new file mode 100644
index 0000000000..c3e493af37
--- /dev/null
+++ b/dom/xslt/xslt/txMozillaTextOutput.h
@@ -0,0 +1,47 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef TRANSFRMX_MOZILLA_TEXT_OUTPUT_H
+#define TRANSFRMX_MOZILLA_TEXT_OUTPUT_H
+
+#include "txXMLEventHandler.h"
+#include "nsCOMPtr.h"
+#include "nsIWeakReferenceUtils.h"
+#include "txOutputFormat.h"
+
+class nsITransformObserver;
+class nsIContent;
+
+namespace mozilla::dom {
+class Document;
+class DocumentFragment;
+class Element;
+} // namespace mozilla::dom
+
+class txMozillaTextOutput : public txAOutputXMLEventHandler {
+ public:
+ explicit txMozillaTextOutput(mozilla::dom::Document* aSourceDocument,
+ nsITransformObserver* aObserver);
+ explicit txMozillaTextOutput(mozilla::dom::DocumentFragment* aDest);
+ virtual ~txMozillaTextOutput();
+
+ TX_DECL_TXAXMLEVENTHANDLER
+ TX_DECL_TXAOUTPUTXMLEVENTHANDLER
+
+ nsresult createResultDocument(bool aLoadedAsData);
+
+ private:
+ nsresult createXHTMLElement(nsAtom* aName, mozilla::dom::Element** aResult);
+
+ nsCOMPtr<mozilla::dom::Document> mSourceDocument;
+ nsCOMPtr<nsIContent> mTextParent;
+ nsWeakPtr mObserver;
+ RefPtr<mozilla::dom::Document> mDocument;
+ txOutputFormat mOutputFormat;
+ nsString mText;
+ bool mCreatedDocument;
+};
+
+#endif
diff --git a/dom/xslt/xslt/txMozillaXMLOutput.cpp b/dom/xslt/xslt/txMozillaXMLOutput.cpp
new file mode 100644
index 0000000000..81f260420b
--- /dev/null
+++ b/dom/xslt/xslt/txMozillaXMLOutput.cpp
@@ -0,0 +1,948 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txMozillaXMLOutput.h"
+
+#include "mozilla/dom/Document.h"
+#include "nsIDocShell.h"
+#include "nsIScriptElement.h"
+#include "nsCharsetSource.h"
+#include "nsIRefreshURI.h"
+#include "nsPIDOMWindow.h"
+#include "nsIContent.h"
+#include "nsContentCID.h"
+#include "nsUnicharUtils.h"
+#include "nsGkAtoms.h"
+#include "txLog.h"
+#include "nsNameSpaceManager.h"
+#include "txStringUtils.h"
+#include "txURIUtils.h"
+#include "nsIDocumentTransformer.h"
+#include "mozilla/StyleSheetInlines.h"
+#include "mozilla/css/Loader.h"
+#include "mozilla/dom/DocumentType.h"
+#include "mozilla/dom/DocumentFragment.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/ScriptLoader.h"
+#include "mozilla/Encoding.h"
+#include "nsContentUtils.h"
+#include "nsDocElementCreatedNotificationRunner.h"
+#include "txXMLUtils.h"
+#include "nsContentSink.h"
+#include "nsINode.h"
+#include "nsContentCreatorFunctions.h"
+#include "nsError.h"
+#include "nsStringFlags.h"
+#include "nsStyleUtil.h"
+#include "nsIFrame.h"
+#include <algorithm>
+#include "nsTextNode.h"
+#include "nsDocShell.h"
+#include "mozilla/dom/Comment.h"
+#include "mozilla/dom/ProcessingInstruction.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+#define TX_ENSURE_CURRENTNODE \
+ NS_ASSERTION(mCurrentNode, "mCurrentNode is nullptr"); \
+ if (!mCurrentNode) return NS_ERROR_UNEXPECTED
+
+txMozillaXMLOutput::txMozillaXMLOutput(Document* aSourceDocument,
+ txOutputFormat* aFormat,
+ nsITransformObserver* aObserver)
+ : mTreeDepth(0),
+ mBadChildLevel(0),
+ mTableState(NORMAL),
+ mCreatingNewDocument(true),
+ mOpenedElementIsHTML(false),
+ mRootContentCreated(false),
+ mNoFixup(false) {
+ MOZ_COUNT_CTOR(txMozillaXMLOutput);
+ if (aObserver) {
+ mNotifier = new txTransformNotifier(aSourceDocument);
+ if (mNotifier) {
+ mNotifier->Init(aObserver);
+ }
+ }
+
+ mOutputFormat.merge(*aFormat);
+ mOutputFormat.setFromDefaults();
+}
+
+txMozillaXMLOutput::txMozillaXMLOutput(txOutputFormat* aFormat,
+ DocumentFragment* aFragment,
+ bool aNoFixup)
+ : mTreeDepth(0),
+ mBadChildLevel(0),
+ mTableState(NORMAL),
+ mCreatingNewDocument(false),
+ mOpenedElementIsHTML(false),
+ mRootContentCreated(false),
+ mNoFixup(aNoFixup) {
+ MOZ_COUNT_CTOR(txMozillaXMLOutput);
+ mOutputFormat.merge(*aFormat);
+ mOutputFormat.setFromDefaults();
+
+ mCurrentNode = aFragment;
+ mDocument = mCurrentNode->OwnerDoc();
+ mNodeInfoManager = mDocument->NodeInfoManager();
+}
+
+txMozillaXMLOutput::~txMozillaXMLOutput() {
+ MOZ_COUNT_DTOR(txMozillaXMLOutput);
+}
+
+nsresult txMozillaXMLOutput::attribute(nsAtom* aPrefix, nsAtom* aLocalName,
+ nsAtom* aLowercaseLocalName,
+ const int32_t aNsID,
+ const nsString& aValue) {
+ RefPtr<nsAtom> owner;
+ if (mOpenedElementIsHTML && aNsID == kNameSpaceID_None) {
+ if (aLowercaseLocalName) {
+ aLocalName = aLowercaseLocalName;
+ } else {
+ owner = TX_ToLowerCaseAtom(aLocalName);
+ NS_ENSURE_TRUE(owner, NS_ERROR_OUT_OF_MEMORY);
+
+ aLocalName = owner;
+ }
+ }
+
+ return attributeInternal(aPrefix, aLocalName, aNsID, aValue);
+}
+
+nsresult txMozillaXMLOutput::attribute(nsAtom* aPrefix,
+ const nsAString& aLocalName,
+ const int32_t aNsID,
+ const nsString& aValue) {
+ RefPtr<nsAtom> lname;
+
+ if (mOpenedElementIsHTML && aNsID == kNameSpaceID_None) {
+ nsAutoString lnameStr;
+ nsContentUtils::ASCIIToLower(aLocalName, lnameStr);
+ lname = NS_Atomize(lnameStr);
+ } else {
+ lname = NS_Atomize(aLocalName);
+ }
+
+ NS_ENSURE_TRUE(lname, NS_ERROR_OUT_OF_MEMORY);
+
+ // Check that it's a valid name
+ if (!nsContentUtils::IsValidNodeName(lname, aPrefix, aNsID)) {
+ // Try without prefix
+ aPrefix = nullptr;
+ if (!nsContentUtils::IsValidNodeName(lname, aPrefix, aNsID)) {
+ // Don't return error here since the callers don't deal
+ return NS_OK;
+ }
+ }
+
+ return attributeInternal(aPrefix, lname, aNsID, aValue);
+}
+
+nsresult txMozillaXMLOutput::attributeInternal(nsAtom* aPrefix,
+ nsAtom* aLocalName,
+ int32_t aNsID,
+ const nsString& aValue) {
+ if (!mOpenedElement) {
+ // XXX Signal this? (can't add attributes after element closed)
+ return NS_OK;
+ }
+
+ NS_ASSERTION(!mBadChildLevel, "mBadChildLevel set when element is opened");
+
+ return mOpenedElement->SetAttr(aNsID, aLocalName, aPrefix, aValue, false);
+}
+
+nsresult txMozillaXMLOutput::characters(const nsAString& aData, bool aDOE) {
+ nsresult rv = closePrevious(false);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (!mBadChildLevel) {
+ mText.Append(aData);
+ }
+
+ return NS_OK;
+}
+
+nsresult txMozillaXMLOutput::comment(const nsString& aData) {
+ nsresult rv = closePrevious(true);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (mBadChildLevel) {
+ return NS_OK;
+ }
+
+ TX_ENSURE_CURRENTNODE;
+
+ RefPtr<Comment> comment = new (mNodeInfoManager) Comment(mNodeInfoManager);
+
+ rv = comment->SetText(aData, false);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ ErrorResult error;
+ mCurrentNode->AppendChildTo(comment, true, error);
+ return error.StealNSResult();
+}
+
+nsresult txMozillaXMLOutput::endDocument(nsresult aResult) {
+ TX_ENSURE_CURRENTNODE;
+
+ if (NS_FAILED(aResult)) {
+ if (mNotifier) {
+ mNotifier->OnTransformEnd(aResult);
+ }
+
+ return NS_OK;
+ }
+
+ nsresult rv = closePrevious(true);
+ if (NS_FAILED(rv)) {
+ if (mNotifier) {
+ mNotifier->OnTransformEnd(rv);
+ }
+
+ return rv;
+ }
+
+ if (mCreatingNewDocument) {
+ // This should really be handled by Document::EndLoad
+ MOZ_ASSERT(mDocument->GetReadyStateEnum() == Document::READYSTATE_LOADING,
+ "Bad readyState");
+ mDocument->SetReadyStateInternal(Document::READYSTATE_INTERACTIVE);
+ if (ScriptLoader* loader = mDocument->ScriptLoader()) {
+ loader->ParsingComplete(false);
+ }
+ }
+
+ if (mNotifier) {
+ mNotifier->OnTransformEnd();
+ }
+
+ return NS_OK;
+}
+
+nsresult txMozillaXMLOutput::endElement() {
+ TX_ENSURE_CURRENTNODE;
+
+ if (mBadChildLevel) {
+ --mBadChildLevel;
+ MOZ_LOG(txLog::xslt, LogLevel::Debug,
+ ("endElement, mBadChildLevel = %d\n", mBadChildLevel));
+ return NS_OK;
+ }
+
+ --mTreeDepth;
+
+ nsresult rv = closePrevious(true);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ NS_ASSERTION(mCurrentNode->IsElement(), "borked mCurrentNode");
+ NS_ENSURE_TRUE(mCurrentNode->IsElement(), NS_ERROR_UNEXPECTED);
+
+ Element* element = mCurrentNode->AsElement();
+
+ // Handle html-elements
+ if (!mNoFixup) {
+ if (element->IsHTMLElement()) {
+ endHTMLElement(element);
+ }
+
+ // Handle elements that are different when parser-created
+ if (nsIContent::RequiresDoneCreatingElement(
+ element->NodeInfo()->NamespaceID(),
+ element->NodeInfo()->NameAtom())) {
+ element->DoneCreatingElement();
+ } else if (element->IsSVGElement(nsGkAtoms::script) ||
+ element->IsHTMLElement(nsGkAtoms::script)) {
+ nsCOMPtr<nsIScriptElement> sele = do_QueryInterface(element);
+ if (sele) {
+ bool block = sele->AttemptToExecute();
+ // If the act of insertion evaluated the script, we're fine.
+ // Else, add this script element to the array of loading scripts.
+ if (block) {
+ mNotifier->AddScriptElement(sele);
+ }
+ } else {
+ MOZ_ASSERT(nsNameSpaceManager::GetInstance()->mSVGDisabled,
+ "Script elements need to implement nsIScriptElement and SVG "
+ "wasn't disabled.");
+ }
+ } else if (nsIContent::RequiresDoneAddingChildren(
+ element->NodeInfo()->NamespaceID(),
+ element->NodeInfo()->NameAtom())) {
+ element->DoneAddingChildren(true);
+ }
+ }
+
+ if (mCreatingNewDocument) {
+ // Handle all sorts of stylesheets
+ if (auto* linkStyle = LinkStyle::FromNode(*mCurrentNode)) {
+ linkStyle->SetEnableUpdates(true);
+ auto updateOrError = linkStyle->UpdateStyleSheet(mNotifier);
+ if (mNotifier && updateOrError.isOk() &&
+ updateOrError.unwrap().ShouldBlock()) {
+ mNotifier->AddPendingStylesheet();
+ }
+ }
+ }
+
+ // Add the element to the tree if it wasn't added before and take one step
+ // up the tree
+ MOZ_ASSERT(!mCurrentNodeStack.IsEmpty(), "empty stack");
+ nsCOMPtr<nsINode> parent;
+ if (!mCurrentNodeStack.IsEmpty()) {
+ parent = mCurrentNodeStack.PopLastElement();
+ }
+
+ if (mCurrentNode == mNonAddedNode) {
+ if (parent == mDocument) {
+ NS_ASSERTION(!mRootContentCreated,
+ "Parent to add to shouldn't be a document if we "
+ "have a root content");
+ mRootContentCreated = true;
+ }
+
+ // Check to make sure that script hasn't inserted the node somewhere
+ // else in the tree
+ if (!mCurrentNode->GetParentNode()) {
+ parent->AppendChildTo(mNonAddedNode, true, IgnoreErrors());
+ }
+ mNonAddedNode = nullptr;
+ }
+
+ mCurrentNode = parent;
+
+ mTableState =
+ static_cast<TableState>(NS_PTR_TO_INT32(mTableStateStack.pop()));
+
+ return NS_OK;
+}
+
+void txMozillaXMLOutput::getOutputDocument(Document** aDocument) {
+ NS_IF_ADDREF(*aDocument = mDocument);
+}
+
+nsresult txMozillaXMLOutput::processingInstruction(const nsString& aTarget,
+ const nsString& aData) {
+ nsresult rv = closePrevious(true);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (mOutputFormat.mMethod == eHTMLOutput) return NS_OK;
+
+ TX_ENSURE_CURRENTNODE;
+
+ rv = nsContentUtils::CheckQName(aTarget, false);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ nsCOMPtr<nsIContent> pi =
+ NS_NewXMLProcessingInstruction(mNodeInfoManager, aTarget, aData);
+
+ LinkStyle* linkStyle = nullptr;
+ if (mCreatingNewDocument) {
+ linkStyle = LinkStyle::FromNode(*pi);
+ if (linkStyle) {
+ linkStyle->SetEnableUpdates(false);
+ }
+ }
+
+ ErrorResult error;
+ mCurrentNode->AppendChildTo(pi, true, error);
+ if (error.Failed()) {
+ return error.StealNSResult();
+ }
+
+ if (linkStyle) {
+ linkStyle->SetEnableUpdates(true);
+ auto updateOrError = linkStyle->UpdateStyleSheet(mNotifier);
+ if (mNotifier && updateOrError.isOk() &&
+ updateOrError.unwrap().ShouldBlock()) {
+ mNotifier->AddPendingStylesheet();
+ }
+ }
+
+ return NS_OK;
+}
+
+nsresult txMozillaXMLOutput::startDocument() {
+ if (mNotifier) {
+ mNotifier->OnTransformStart();
+ }
+
+ if (mCreatingNewDocument) {
+ ScriptLoader* loader = mDocument->ScriptLoader();
+ if (loader) {
+ loader->BeginDeferringScripts();
+ }
+ }
+
+ return NS_OK;
+}
+
+nsresult txMozillaXMLOutput::startElement(nsAtom* aPrefix, nsAtom* aLocalName,
+ nsAtom* aLowercaseLocalName,
+ const int32_t aNsID) {
+ MOZ_ASSERT(aNsID != kNameSpaceID_None || !aPrefix,
+ "Can't have prefix without namespace");
+
+ if (mOutputFormat.mMethod == eHTMLOutput && aNsID == kNameSpaceID_None) {
+ RefPtr<nsAtom> owner;
+ if (!aLowercaseLocalName) {
+ owner = TX_ToLowerCaseAtom(aLocalName);
+ NS_ENSURE_TRUE(owner, NS_ERROR_OUT_OF_MEMORY);
+
+ aLowercaseLocalName = owner;
+ }
+ return startElementInternal(nullptr, aLowercaseLocalName,
+ kNameSpaceID_XHTML);
+ }
+
+ return startElementInternal(aPrefix, aLocalName, aNsID);
+}
+
+nsresult txMozillaXMLOutput::startElement(nsAtom* aPrefix,
+ const nsAString& aLocalName,
+ const int32_t aNsID) {
+ int32_t nsId = aNsID;
+ RefPtr<nsAtom> lname;
+
+ if (mOutputFormat.mMethod == eHTMLOutput && aNsID == kNameSpaceID_None) {
+ nsId = kNameSpaceID_XHTML;
+
+ nsAutoString lnameStr;
+ nsContentUtils::ASCIIToLower(aLocalName, lnameStr);
+ lname = NS_Atomize(lnameStr);
+ } else {
+ lname = NS_Atomize(aLocalName);
+ }
+
+ // No biggie if we lose the prefix due to OOM
+ NS_ENSURE_TRUE(lname, NS_ERROR_OUT_OF_MEMORY);
+
+ // Check that it's a valid name
+ if (!nsContentUtils::IsValidNodeName(lname, aPrefix, nsId)) {
+ // Try without prefix
+ aPrefix = nullptr;
+ if (!nsContentUtils::IsValidNodeName(lname, aPrefix, nsId)) {
+ return NS_ERROR_XSLT_BAD_NODE_NAME;
+ }
+ }
+
+ return startElementInternal(aPrefix, lname, nsId);
+}
+
+nsresult txMozillaXMLOutput::startElementInternal(nsAtom* aPrefix,
+ nsAtom* aLocalName,
+ int32_t aNsID) {
+ TX_ENSURE_CURRENTNODE;
+
+ if (mBadChildLevel) {
+ ++mBadChildLevel;
+ MOZ_LOG(txLog::xslt, LogLevel::Debug,
+ ("startElement, mBadChildLevel = %d\n", mBadChildLevel));
+ return NS_OK;
+ }
+
+ nsresult rv = closePrevious(true);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // Push and init state
+ if (mTreeDepth == MAX_REFLOW_DEPTH) {
+ // eCloseElement couldn't add the parent so we fail as well or we've
+ // reached the limit of the depth of the tree that we allow.
+ ++mBadChildLevel;
+ MOZ_LOG(txLog::xslt, LogLevel::Debug,
+ ("startElement, mBadChildLevel = %d\n", mBadChildLevel));
+ return NS_OK;
+ }
+
+ ++mTreeDepth;
+
+ mTableStateStack.push(NS_INT32_TO_PTR(mTableState));
+
+ mCurrentNodeStack.AppendElement(mCurrentNode);
+
+ mTableState = NORMAL;
+ mOpenedElementIsHTML = false;
+
+ // Create the element
+ RefPtr<NodeInfo> ni = mNodeInfoManager->GetNodeInfo(
+ aLocalName, aPrefix, aNsID, nsINode::ELEMENT_NODE);
+
+ NS_NewElement(getter_AddRefs(mOpenedElement), ni.forget(),
+ mCreatingNewDocument ? FROM_PARSER_XSLT : FROM_PARSER_FRAGMENT);
+
+ // Set up the element and adjust state
+ if (!mNoFixup) {
+ if (aNsID == kNameSpaceID_XHTML) {
+ mOpenedElementIsHTML = (mOutputFormat.mMethod == eHTMLOutput);
+ rv = startHTMLElement(mOpenedElement, mOpenedElementIsHTML);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ }
+
+ if (mCreatingNewDocument) {
+ // Handle all sorts of stylesheets
+ if (auto* linkStyle = LinkStyle::FromNodeOrNull(mOpenedElement)) {
+ linkStyle->SetEnableUpdates(false);
+ }
+ }
+
+ return NS_OK;
+}
+
+nsresult txMozillaXMLOutput::closePrevious(bool aFlushText) {
+ TX_ENSURE_CURRENTNODE;
+
+ nsresult rv;
+ if (mOpenedElement) {
+ bool currentIsDoc = mCurrentNode == mDocument;
+ if (currentIsDoc && mRootContentCreated) {
+ // We already have a document element, but the XSLT spec allows this.
+ // As a workaround, create a wrapper object and use that as the
+ // document element.
+
+ rv = createTxWrapper();
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ ErrorResult error;
+ mCurrentNode->AppendChildTo(mOpenedElement, true, error);
+ if (error.Failed()) {
+ return error.StealNSResult();
+ }
+
+ if (currentIsDoc) {
+ mRootContentCreated = true;
+ nsContentUtils::AddScriptRunner(
+ new nsDocElementCreatedNotificationRunner(mDocument));
+ }
+
+ mCurrentNode = mOpenedElement;
+ mOpenedElement = nullptr;
+ } else if (aFlushText && !mText.IsEmpty()) {
+ // Text can't appear in the root of a document
+ if (mDocument == mCurrentNode) {
+ if (XMLUtils::isWhitespace(mText)) {
+ mText.Truncate();
+
+ return NS_OK;
+ }
+
+ rv = createTxWrapper();
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ RefPtr<nsTextNode> text =
+ new (mNodeInfoManager) nsTextNode(mNodeInfoManager);
+
+ rv = text->SetText(mText, false);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ ErrorResult error;
+ mCurrentNode->AppendChildTo(text, true, error);
+ if (error.Failed()) {
+ return error.StealNSResult();
+ }
+
+ mText.Truncate();
+ }
+
+ return NS_OK;
+}
+
+nsresult txMozillaXMLOutput::createTxWrapper() {
+ NS_ASSERTION(mDocument == mCurrentNode,
+ "creating wrapper when document isn't parent");
+
+ int32_t namespaceID;
+ nsresult rv = nsNameSpaceManager::GetInstance()->RegisterNameSpace(
+ nsLiteralString(kTXNameSpaceURI), namespaceID);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ nsCOMPtr<Element> wrapper =
+ mDocument->CreateElem(nsDependentAtomString(nsGkAtoms::result),
+ nsGkAtoms::transformiix, namespaceID);
+
+#ifdef DEBUG
+ // Keep track of the location of the current documentElement, if there is
+ // one, so we can verify later
+ uint32_t j = 0, rootLocation = 0;
+#endif
+ for (nsCOMPtr<nsIContent> childContent = mDocument->GetFirstChild();
+ childContent; childContent = childContent->GetNextSibling()) {
+#ifdef DEBUG
+ if (childContent->IsElement()) {
+ rootLocation = j;
+ }
+#endif
+
+ if (childContent->NodeInfo()->NameAtom() ==
+ nsGkAtoms::documentTypeNodeName) {
+#ifdef DEBUG
+ // The new documentElement should go after the document type.
+ // This is needed for cases when there is no existing
+ // documentElement in the document.
+ rootLocation = std::max(rootLocation, j + 1);
+ ++j;
+#endif
+ } else {
+ mDocument->RemoveChildNode(childContent, true);
+
+ ErrorResult error;
+ wrapper->AppendChildTo(childContent, true, error);
+ if (error.Failed()) {
+ return error.StealNSResult();
+ }
+ break;
+ }
+ }
+
+ mCurrentNodeStack.AppendElement(wrapper);
+ mCurrentNode = wrapper;
+ mRootContentCreated = true;
+ NS_ASSERTION(rootLocation == mDocument->GetChildCount(),
+ "Incorrect root location");
+ ErrorResult error;
+ mDocument->AppendChildTo(wrapper, true, error);
+ return error.StealNSResult();
+}
+
+nsresult txMozillaXMLOutput::startHTMLElement(nsIContent* aElement,
+ bool aIsHTML) {
+ nsresult rv = NS_OK;
+
+ if ((!aElement->IsHTMLElement(nsGkAtoms::tr) || !aIsHTML) &&
+ NS_PTR_TO_INT32(mTableStateStack.peek()) == ADDED_TBODY) {
+ MOZ_ASSERT(!mCurrentNodeStack.IsEmpty(), "empty stack");
+ if (mCurrentNodeStack.IsEmpty()) {
+ mCurrentNode = nullptr;
+ } else {
+ mCurrentNode = mCurrentNodeStack.PopLastElement();
+ }
+ mTableStateStack.pop();
+ }
+
+ if (aElement->IsHTMLElement(nsGkAtoms::table) && aIsHTML) {
+ mTableState = TABLE;
+ } else if (aElement->IsHTMLElement(nsGkAtoms::tr) && aIsHTML &&
+ NS_PTR_TO_INT32(mTableStateStack.peek()) == TABLE) {
+ RefPtr<Element> tbody;
+ rv = createHTMLElement(nsGkAtoms::tbody, getter_AddRefs(tbody));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ ErrorResult error;
+ mCurrentNode->AppendChildTo(tbody, true, error);
+ if (error.Failed()) {
+ return error.StealNSResult();
+ }
+
+ mTableStateStack.push(NS_INT32_TO_PTR(ADDED_TBODY));
+
+ mCurrentNodeStack.AppendElement(tbody);
+ mCurrentNode = tbody;
+ } else if (aElement->IsHTMLElement(nsGkAtoms::head) &&
+ mOutputFormat.mMethod == eHTMLOutput) {
+ // Insert META tag, according to spec, 16.2, like
+ // <META http-equiv="Content-Type" content="text/html; charset=EUC-JP">
+ RefPtr<Element> meta;
+ rv = createHTMLElement(nsGkAtoms::meta, getter_AddRefs(meta));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = meta->SetAttr(kNameSpaceID_None, nsGkAtoms::httpEquiv,
+ u"Content-Type"_ns, false);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ nsAutoString metacontent;
+ CopyUTF8toUTF16(mOutputFormat.mMediaType, metacontent);
+ metacontent.AppendLiteral("; charset=");
+ metacontent.Append(mOutputFormat.mEncoding);
+ rv = meta->SetAttr(kNameSpaceID_None, nsGkAtoms::content, metacontent,
+ false);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // No need to notify since aElement hasn't been inserted yet
+ NS_ASSERTION(!aElement->IsInUncomposedDoc(), "should not be in doc");
+ ErrorResult error;
+ aElement->AppendChildTo(meta, false, error);
+ if (error.Failed()) {
+ return error.StealNSResult();
+ }
+ }
+
+ return NS_OK;
+}
+
+void txMozillaXMLOutput::endHTMLElement(nsIContent* aElement) {
+ if (mTableState == ADDED_TBODY) {
+ NS_ASSERTION(aElement->IsHTMLElement(nsGkAtoms::tbody),
+ "Element flagged as added tbody isn't a tbody");
+ MOZ_ASSERT(!mCurrentNodeStack.IsEmpty(), "empty stack");
+ if (mCurrentNodeStack.IsEmpty()) {
+ mCurrentNode = nullptr;
+ } else {
+ mCurrentNode = mCurrentNodeStack.PopLastElement();
+ }
+ mTableState =
+ static_cast<TableState>(NS_PTR_TO_INT32(mTableStateStack.pop()));
+ }
+}
+
+nsresult txMozillaXMLOutput::createResultDocument(const nsAString& aName,
+ int32_t aNsID,
+ Document* aSourceDocument,
+ bool aLoadedAsData) {
+ nsresult rv;
+
+ // Create the document
+ if (mOutputFormat.mMethod == eHTMLOutput) {
+ rv = NS_NewHTMLDocument(getter_AddRefs(mDocument), aLoadedAsData);
+ NS_ENSURE_SUCCESS(rv, rv);
+ } else {
+ // We should check the root name/namespace here and create the
+ // appropriate document
+ rv = NS_NewXMLDocument(getter_AddRefs(mDocument), aLoadedAsData);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ // This should really be handled by Document::BeginLoad
+ MOZ_ASSERT(
+ mDocument->GetReadyStateEnum() == Document::READYSTATE_UNINITIALIZED,
+ "Bad readyState");
+ mDocument->SetReadyStateInternal(Document::READYSTATE_LOADING);
+ mDocument->SetMayStartLayout(false);
+ bool hasHadScriptObject = false;
+ nsIScriptGlobalObject* sgo =
+ aSourceDocument->GetScriptHandlingObject(hasHadScriptObject);
+ NS_ENSURE_STATE(sgo || !hasHadScriptObject);
+
+ mCurrentNode = mDocument;
+ mNodeInfoManager = mDocument->NodeInfoManager();
+
+ // Reset and set up the document
+ URIUtils::ResetWithSource(mDocument, aSourceDocument);
+
+ // Make sure we set the script handling object after resetting with the
+ // source, so that we have the right principal.
+ mDocument->SetScriptHandlingObject(sgo);
+
+ mDocument->SetStateObjectFrom(aSourceDocument);
+
+ // Set the charset
+ if (!mOutputFormat.mEncoding.IsEmpty()) {
+ const Encoding* encoding = Encoding::ForLabel(mOutputFormat.mEncoding);
+ if (encoding) {
+ mDocument->SetDocumentCharacterSetSource(kCharsetFromOtherComponent);
+ mDocument->SetDocumentCharacterSet(WrapNotNull(encoding));
+ }
+ }
+
+ // Set the mime-type
+ if (!mOutputFormat.mMediaType.IsEmpty()) {
+ mDocument->SetContentType(mOutputFormat.mMediaType);
+ } else if (mOutputFormat.mMethod == eHTMLOutput) {
+ mDocument->SetContentType("text/html"_ns);
+ } else {
+ mDocument->SetContentType("application/xml"_ns);
+ }
+
+ if (mOutputFormat.mMethod == eXMLOutput &&
+ mOutputFormat.mOmitXMLDeclaration != eTrue) {
+ int32_t standalone;
+ if (mOutputFormat.mStandalone == eNotSet) {
+ standalone = -1;
+ } else if (mOutputFormat.mStandalone == eFalse) {
+ standalone = 0;
+ } else {
+ standalone = 1;
+ }
+
+ // Could use mOutputFormat.mVersion.get() when we support
+ // versions > 1.0.
+ static const char16_t kOneDotZero[] = {'1', '.', '0', '\0'};
+ mDocument->SetXMLDeclaration(kOneDotZero, mOutputFormat.mEncoding.get(),
+ standalone);
+ }
+
+ // Set up script loader of the result document.
+ ScriptLoader* loader = mDocument->ScriptLoader();
+ if (mNotifier) {
+ loader->AddObserver(mNotifier);
+ } else {
+ // Don't load scripts, we can't notify the caller when they're loaded.
+ loader->SetEnabled(false);
+ }
+
+ if (mNotifier) {
+ rv = mNotifier->SetOutputDocument(mDocument);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = mDocument->InitFeaturePolicy(mDocument->GetChannel());
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ // Do this after calling OnDocumentCreated to ensure that the
+ // PresShell/PresContext has been hooked up and get notified.
+ if (mDocument) {
+ mDocument->SetCompatibilityMode(eCompatibility_FullStandards);
+ }
+
+ // Add a doc-type if requested
+ if (!mOutputFormat.mSystemId.IsEmpty()) {
+ nsAutoString qName;
+ if (mOutputFormat.mMethod == eHTMLOutput) {
+ qName.AssignLiteral("html");
+ } else {
+ qName.Assign(aName);
+ }
+
+ nsresult rv = nsContentUtils::CheckQName(qName);
+ if (NS_SUCCEEDED(rv)) {
+ RefPtr<nsAtom> doctypeName = NS_Atomize(qName);
+ if (!doctypeName) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ // Indicate that there is no internal subset (not just an empty one)
+ RefPtr<DocumentType> documentType = NS_NewDOMDocumentType(
+ mNodeInfoManager, doctypeName, mOutputFormat.mPublicId,
+ mOutputFormat.mSystemId, VoidString());
+
+ ErrorResult error;
+ mDocument->AppendChildTo(documentType, true, error);
+ if (error.Failed()) {
+ return error.StealNSResult();
+ }
+ }
+ }
+
+ return NS_OK;
+}
+
+nsresult txMozillaXMLOutput::createHTMLElement(nsAtom* aName,
+ Element** aResult) {
+ NS_ASSERTION(mOutputFormat.mMethod == eHTMLOutput,
+ "need to adjust createHTMLElement");
+
+ *aResult = nullptr;
+
+ RefPtr<NodeInfo> ni;
+ ni = mNodeInfoManager->GetNodeInfo(aName, nullptr, kNameSpaceID_XHTML,
+ nsINode::ELEMENT_NODE);
+
+ nsCOMPtr<Element> el;
+ nsresult rv = NS_NewHTMLElement(
+ getter_AddRefs(el), ni.forget(),
+ mCreatingNewDocument ? FROM_PARSER_XSLT : FROM_PARSER_FRAGMENT);
+ el.forget(aResult);
+ return rv;
+}
+
+txTransformNotifier::txTransformNotifier(Document* aSourceDocument)
+ : mSourceDocument(aSourceDocument),
+ mPendingStylesheetCount(0),
+ mInTransform(false) {}
+
+txTransformNotifier::~txTransformNotifier() = default;
+
+NS_IMPL_ISUPPORTS(txTransformNotifier, nsIScriptLoaderObserver,
+ nsICSSLoaderObserver)
+
+NS_IMETHODIMP
+txTransformNotifier::ScriptAvailable(nsresult aResult,
+ nsIScriptElement* aElement,
+ bool aIsInlineClassicScript, nsIURI* aURI,
+ uint32_t aLineNo) {
+ if (NS_FAILED(aResult) && mScriptElements.RemoveElement(aElement)) {
+ SignalTransformEnd();
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+txTransformNotifier::ScriptEvaluated(nsresult aResult,
+ nsIScriptElement* aElement,
+ bool aIsInline) {
+ if (mScriptElements.RemoveElement(aElement)) {
+ SignalTransformEnd();
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+txTransformNotifier::StyleSheetLoaded(StyleSheet* aSheet, bool aWasDeferred,
+ nsresult aStatus) {
+ if (mPendingStylesheetCount == 0) {
+ // We weren't waiting on this stylesheet anyway. This can happen if
+ // SignalTransformEnd got called with an error aResult. See
+ // http://bugzilla.mozilla.org/show_bug.cgi?id=215465.
+ return NS_OK;
+ }
+
+ // We're never waiting for alternate stylesheets
+ if (!aWasDeferred) {
+ --mPendingStylesheetCount;
+ SignalTransformEnd();
+ }
+
+ return NS_OK;
+}
+
+void txTransformNotifier::Init(nsITransformObserver* aObserver) {
+ mObserver = aObserver;
+}
+
+void txTransformNotifier::AddScriptElement(nsIScriptElement* aElement) {
+ mScriptElements.AppendElement(aElement);
+}
+
+void txTransformNotifier::AddPendingStylesheet() { ++mPendingStylesheetCount; }
+
+void txTransformNotifier::OnTransformEnd(nsresult aResult) {
+ mInTransform = false;
+ SignalTransformEnd(aResult);
+}
+
+void txTransformNotifier::OnTransformStart() { mInTransform = true; }
+
+nsresult txTransformNotifier::SetOutputDocument(Document* aDocument) {
+ mDocument = aDocument;
+
+ // Notify the contentsink that the document is created
+ return mObserver->OnDocumentCreated(mSourceDocument, mDocument);
+}
+
+void txTransformNotifier::SignalTransformEnd(nsresult aResult) {
+ if (mInTransform ||
+ (NS_SUCCEEDED(aResult) &&
+ (!mScriptElements.IsEmpty() || mPendingStylesheetCount > 0))) {
+ return;
+ }
+
+ // mPendingStylesheetCount is nonzero at this point only if aResult is an
+ // error. Set it to 0 so we won't reenter this code when we stop the
+ // CSSLoader.
+ mPendingStylesheetCount = 0;
+ mScriptElements.Clear();
+
+ // Make sure that we don't get deleted while this function is executed and
+ // we remove ourselfs from the scriptloader
+ nsCOMPtr<nsIScriptLoaderObserver> kungFuDeathGrip(this);
+
+ if (mDocument) {
+ mDocument->ScriptLoader()->DeferCheckpointReached();
+ mDocument->ScriptLoader()->RemoveObserver(this);
+ // XXX Maybe we want to cancel script loads if NS_FAILED(rv)?
+
+ if (NS_FAILED(aResult)) {
+ mDocument->CSSLoader()->Stop();
+ }
+ }
+
+ if (NS_SUCCEEDED(aResult)) {
+ mObserver->OnTransformDone(mSourceDocument, aResult, mDocument);
+ }
+}
diff --git a/dom/xslt/xslt/txMozillaXMLOutput.h b/dom/xslt/xslt/txMozillaXMLOutput.h
new file mode 100644
index 0000000000..c77ecb6aae
--- /dev/null
+++ b/dom/xslt/xslt/txMozillaXMLOutput.h
@@ -0,0 +1,130 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef TRANSFRMX_MOZILLA_XML_OUTPUT_H
+#define TRANSFRMX_MOZILLA_XML_OUTPUT_H
+
+#include "txXMLEventHandler.h"
+#include "nsIScriptLoaderObserver.h"
+#include "txOutputFormat.h"
+#include "nsTArray.h"
+#include "nsCOMPtr.h"
+#include "nsICSSLoaderObserver.h"
+#include "txStack.h"
+#include "mozilla/Attributes.h"
+
+class nsIContent;
+class nsAtom;
+class nsITransformObserver;
+class nsNodeInfoManager;
+class nsINode;
+
+namespace mozilla::dom {
+class Document;
+class DocumentFragment;
+class Element;
+} // namespace mozilla::dom
+
+class txTransformNotifier final : public nsIScriptLoaderObserver,
+ public nsICSSLoaderObserver {
+ public:
+ explicit txTransformNotifier(mozilla::dom::Document* aSourceDocument);
+
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSISCRIPTLOADEROBSERVER
+
+ // nsICSSLoaderObserver
+ NS_IMETHOD StyleSheetLoaded(mozilla::StyleSheet* aSheet, bool aWasDeferred,
+ nsresult aStatus) override;
+
+ void Init(nsITransformObserver* aObserver);
+ void AddScriptElement(nsIScriptElement* aElement);
+ void AddPendingStylesheet();
+ void OnTransformEnd(nsresult aResult = NS_OK);
+ void OnTransformStart();
+ nsresult SetOutputDocument(mozilla::dom::Document* aDocument);
+
+ private:
+ ~txTransformNotifier();
+ void SignalTransformEnd(nsresult aResult = NS_OK);
+
+ nsCOMPtr<mozilla::dom::Document> mSourceDocument;
+ nsCOMPtr<mozilla::dom::Document> mDocument;
+ nsCOMPtr<nsITransformObserver> mObserver;
+ nsTArray<nsCOMPtr<nsIScriptElement>> mScriptElements;
+ uint32_t mPendingStylesheetCount;
+ bool mInTransform;
+};
+
+class txMozillaXMLOutput : public txAOutputXMLEventHandler {
+ public:
+ txMozillaXMLOutput(mozilla::dom::Document* aSourceDocument,
+ txOutputFormat* aFormat, nsITransformObserver* aObserver);
+ txMozillaXMLOutput(txOutputFormat* aFormat,
+ mozilla::dom::DocumentFragment* aFragment, bool aNoFixup);
+ ~txMozillaXMLOutput();
+
+ TX_DECL_TXAXMLEVENTHANDLER
+ TX_DECL_TXAOUTPUTXMLEVENTHANDLER
+
+ nsresult closePrevious(bool aFlushText);
+
+ nsresult createResultDocument(const nsAString& aName, int32_t aNsID,
+ mozilla::dom::Document* aSourceDocument,
+ bool aLoadedAsData);
+
+ private:
+ nsresult createTxWrapper();
+ nsresult startHTMLElement(nsIContent* aElement, bool aXHTML);
+ void endHTMLElement(nsIContent* aElement);
+ nsresult createHTMLElement(nsAtom* aName, mozilla::dom::Element** aResult);
+
+ nsresult attributeInternal(nsAtom* aPrefix, nsAtom* aLocalName, int32_t aNsID,
+ const nsString& aValue);
+ nsresult startElementInternal(nsAtom* aPrefix, nsAtom* aLocalName,
+ int32_t aNsID);
+
+ RefPtr<mozilla::dom::Document> mDocument;
+ nsCOMPtr<nsINode> mCurrentNode; // This is updated once an element is
+ // 'closed' (i.e. once we're done
+ // adding attributes to it).
+ // until then the opened element is
+ // kept in mOpenedElement
+ nsCOMPtr<mozilla::dom::Element> mOpenedElement;
+ RefPtr<nsNodeInfoManager> mNodeInfoManager;
+
+ nsTArray<nsCOMPtr<nsINode>> mCurrentNodeStack;
+
+ nsCOMPtr<nsIContent> mNonAddedNode;
+
+ RefPtr<txTransformNotifier> mNotifier;
+
+ uint32_t mTreeDepth, mBadChildLevel;
+
+ txStack mTableStateStack;
+ enum TableState {
+ NORMAL, // An element needing no special treatment
+ TABLE, // A HTML table element
+ ADDED_TBODY // An inserted tbody not coming from the stylesheet
+ };
+ TableState mTableState;
+
+ nsAutoString mText;
+
+ txOutputFormat mOutputFormat;
+
+ bool mCreatingNewDocument;
+
+ bool mOpenedElementIsHTML;
+
+ // Set to true when we know there's a root content in our document.
+ bool mRootContentCreated;
+
+ bool mNoFixup;
+
+ enum txAction { eCloseElement = 1, eFlushText = 2 };
+};
+
+#endif
diff --git a/dom/xslt/xslt/txMozillaXSLTProcessor.cpp b/dom/xslt/xslt/txMozillaXSLTProcessor.cpp
new file mode 100644
index 0000000000..f3d4272e6f
--- /dev/null
+++ b/dom/xslt/xslt/txMozillaXSLTProcessor.cpp
@@ -0,0 +1,1227 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txMozillaXSLTProcessor.h"
+#include "nsContentCID.h"
+#include "nsError.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/Document.h"
+#include "nsIStringBundle.h"
+#include "nsIURI.h"
+#include "XPathResult.h"
+#include "txExecutionState.h"
+#include "txMozillaTextOutput.h"
+#include "txMozillaXMLOutput.h"
+#include "txURIUtils.h"
+#include "txXMLUtils.h"
+#include "txUnknownHandler.h"
+#include "txXSLTMsgsURL.h"
+#include "txXSLTProcessor.h"
+#include "nsIPrincipal.h"
+#include "nsThreadUtils.h"
+#include "jsapi.h"
+#include "txExprParser.h"
+#include "nsJSUtils.h"
+#include "nsIXPConnect.h"
+#include "nsNameSpaceManager.h"
+#include "nsVariant.h"
+#include "nsTextNode.h"
+#include "mozilla/Components.h"
+#include "mozilla/dom/DocumentFragment.h"
+#include "mozilla/dom/XSLTProcessorBinding.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+/**
+ * Output Handler Factories
+ */
+class txToDocHandlerFactory : public txAOutputHandlerFactory {
+ public:
+ txToDocHandlerFactory(txExecutionState* aEs, Document* aSourceDocument,
+ nsITransformObserver* aObserver, bool aDocumentIsData)
+ : mEs(aEs),
+ mSourceDocument(aSourceDocument),
+ mObserver(aObserver),
+ mDocumentIsData(aDocumentIsData) {}
+
+ TX_DECL_TXAOUTPUTHANDLERFACTORY
+
+ private:
+ txExecutionState* mEs;
+ nsCOMPtr<Document> mSourceDocument;
+ nsCOMPtr<nsITransformObserver> mObserver;
+ bool mDocumentIsData;
+};
+
+class txToFragmentHandlerFactory : public txAOutputHandlerFactory {
+ public:
+ explicit txToFragmentHandlerFactory(DocumentFragment* aFragment)
+ : mFragment(aFragment) {}
+
+ TX_DECL_TXAOUTPUTHANDLERFACTORY
+
+ private:
+ RefPtr<DocumentFragment> mFragment;
+};
+
+nsresult txToDocHandlerFactory::createHandlerWith(
+ txOutputFormat* aFormat, txAXMLEventHandler** aHandler) {
+ *aHandler = nullptr;
+ switch (aFormat->mMethod) {
+ case eMethodNotSet:
+ case eXMLOutput: {
+ *aHandler = new txUnknownHandler(mEs);
+ return NS_OK;
+ }
+
+ case eHTMLOutput: {
+ UniquePtr<txMozillaXMLOutput> handler(
+ new txMozillaXMLOutput(mSourceDocument, aFormat, mObserver));
+
+ nsresult rv = handler->createResultDocument(
+ u""_ns, kNameSpaceID_None, mSourceDocument, mDocumentIsData);
+ if (NS_SUCCEEDED(rv)) {
+ *aHandler = handler.release();
+ }
+
+ return rv;
+ }
+
+ case eTextOutput: {
+ UniquePtr<txMozillaTextOutput> handler(
+ new txMozillaTextOutput(mSourceDocument, mObserver));
+
+ nsresult rv = handler->createResultDocument(mDocumentIsData);
+ if (NS_SUCCEEDED(rv)) {
+ *aHandler = handler.release();
+ }
+
+ return rv;
+ }
+ }
+
+ MOZ_CRASH("Unknown output method");
+
+ return NS_ERROR_FAILURE;
+}
+
+nsresult txToDocHandlerFactory::createHandlerWith(
+ txOutputFormat* aFormat, const nsAString& aName, int32_t aNsID,
+ txAXMLEventHandler** aHandler) {
+ *aHandler = nullptr;
+ switch (aFormat->mMethod) {
+ case eMethodNotSet: {
+ NS_ERROR("How can method not be known when root element is?");
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ case eXMLOutput:
+ case eHTMLOutput: {
+ UniquePtr<txMozillaXMLOutput> handler(
+ new txMozillaXMLOutput(mSourceDocument, aFormat, mObserver));
+
+ nsresult rv = handler->createResultDocument(aName, aNsID, mSourceDocument,
+ mDocumentIsData);
+ if (NS_SUCCEEDED(rv)) {
+ *aHandler = handler.release();
+ }
+
+ return rv;
+ }
+
+ case eTextOutput: {
+ UniquePtr<txMozillaTextOutput> handler(
+ new txMozillaTextOutput(mSourceDocument, mObserver));
+
+ nsresult rv = handler->createResultDocument(mDocumentIsData);
+ if (NS_SUCCEEDED(rv)) {
+ *aHandler = handler.release();
+ }
+
+ return rv;
+ }
+ }
+
+ MOZ_CRASH("Unknown output method");
+
+ return NS_ERROR_FAILURE;
+}
+
+nsresult txToFragmentHandlerFactory::createHandlerWith(
+ txOutputFormat* aFormat, txAXMLEventHandler** aHandler) {
+ *aHandler = nullptr;
+ switch (aFormat->mMethod) {
+ case eMethodNotSet: {
+ txOutputFormat format;
+ format.merge(*aFormat);
+ nsCOMPtr<Document> doc = mFragment->OwnerDoc();
+
+ if (doc->IsHTMLDocument()) {
+ format.mMethod = eHTMLOutput;
+ } else {
+ format.mMethod = eXMLOutput;
+ }
+
+ *aHandler = new txMozillaXMLOutput(&format, mFragment, false);
+ break;
+ }
+
+ case eXMLOutput:
+ case eHTMLOutput: {
+ *aHandler = new txMozillaXMLOutput(aFormat, mFragment, false);
+ break;
+ }
+
+ case eTextOutput: {
+ *aHandler = new txMozillaTextOutput(mFragment);
+ break;
+ }
+ }
+ return NS_OK;
+}
+
+nsresult txToFragmentHandlerFactory::createHandlerWith(
+ txOutputFormat* aFormat, const nsAString& aName, int32_t aNsID,
+ txAXMLEventHandler** aHandler) {
+ *aHandler = nullptr;
+ NS_ASSERTION(aFormat->mMethod != eMethodNotSet,
+ "How can method not be known when root element is?");
+ NS_ENSURE_TRUE(aFormat->mMethod != eMethodNotSet, NS_ERROR_UNEXPECTED);
+ return createHandlerWith(aFormat, aHandler);
+}
+
+class txVariable : public txIGlobalParameter {
+ using XSLTParameterValue = txMozillaXSLTProcessor::XSLTParameterValue;
+ using OwningXSLTParameterValue =
+ txMozillaXSLTProcessor::OwningXSLTParameterValue;
+
+ public:
+ explicit txVariable(UniquePtr<OwningXSLTParameterValue>&& aValue)
+ : mUnionValue(std::move(aValue)) {}
+ nsresult getValue(txAExprResult** aValue) override {
+ if (!mValue) {
+ nsresult rv = convert(*mUnionValue, getter_AddRefs(mValue));
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ NS_ADDREF(*aValue = mValue);
+
+ return NS_OK;
+ }
+ OwningXSLTParameterValue getUnionValue() {
+ return OwningXSLTParameterValue(*mUnionValue);
+ }
+ void setValue(UniquePtr<OwningXSLTParameterValue>&& aValue) {
+ mValue = nullptr;
+ mUnionValue = std::move(aValue);
+ }
+
+ static UniquePtr<OwningXSLTParameterValue> convertToOwning(
+ const XSLTParameterValue& aValue, ErrorResult& aError);
+
+ friend void ImplCycleCollectionTraverse(
+ nsCycleCollectionTraversalCallback& aCallback, txVariable& aVariable,
+ const char* aName, uint32_t aFlags);
+
+ private:
+ static nsresult convert(const OwningXSLTParameterValue& aUnionValue,
+ txAExprResult** aValue);
+
+ UniquePtr<OwningXSLTParameterValue> mUnionValue;
+ RefPtr<txAExprResult> mValue;
+};
+
+inline void ImplCycleCollectionTraverse(
+ nsCycleCollectionTraversalCallback& aCallback, txVariable& aVariable,
+ const char* aName, uint32_t aFlags) {
+ ImplCycleCollectionTraverse(aCallback, *aVariable.mUnionValue, aName, aFlags);
+}
+
+inline void ImplCycleCollectionUnlink(
+ txOwningExpandedNameMap<txIGlobalParameter>& aMap) {
+ aMap.clear();
+}
+
+inline void ImplCycleCollectionTraverse(
+ nsCycleCollectionTraversalCallback& aCallback,
+ txOwningExpandedNameMap<txIGlobalParameter>& aMap, const char* aName,
+ uint32_t aFlags = 0) {
+ aFlags |= CycleCollectionEdgeNameArrayFlag;
+ txOwningExpandedNameMap<txIGlobalParameter>::iterator iter(aMap);
+ while (iter.next()) {
+ ImplCycleCollectionTraverse(
+ aCallback, *static_cast<txVariable*>(iter.value()), aName, aFlags);
+ }
+}
+
+/**
+ * txMozillaXSLTProcessor
+ */
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(txMozillaXSLTProcessor, mOwner,
+ mEmbeddedStylesheetRoot, mSource,
+ mVariables)
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(txMozillaXSLTProcessor)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(txMozillaXSLTProcessor)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(txMozillaXSLTProcessor)
+ NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+ NS_INTERFACE_MAP_ENTRY(nsIDocumentTransformer)
+ NS_INTERFACE_MAP_ENTRY(nsIMutationObserver)
+ NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDocumentTransformer)
+NS_INTERFACE_MAP_END
+
+txMozillaXSLTProcessor::txMozillaXSLTProcessor()
+ : mOwner(nullptr),
+ mStylesheetDocument(nullptr),
+ mTransformResult(NS_OK),
+ mCompileResult(NS_OK),
+ mFlags(0) {}
+
+txMozillaXSLTProcessor::txMozillaXSLTProcessor(nsISupports* aOwner)
+ : mOwner(aOwner),
+ mStylesheetDocument(nullptr),
+ mTransformResult(NS_OK),
+ mCompileResult(NS_OK),
+ mFlags(0) {}
+
+txMozillaXSLTProcessor::~txMozillaXSLTProcessor() {
+ if (mStylesheetDocument) {
+ mStylesheetDocument->RemoveMutationObserver(this);
+ }
+}
+
+NS_IMETHODIMP
+txMozillaXSLTProcessor::SetTransformObserver(nsITransformObserver* aObserver) {
+ mObserver = aObserver;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+txMozillaXSLTProcessor::SetSourceContentModel(nsINode* aSource) {
+ mSource = aSource;
+
+ if (NS_FAILED(mTransformResult)) {
+ notifyError();
+ return NS_OK;
+ }
+
+ if (mStylesheet) {
+ return DoTransform();
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+txMozillaXSLTProcessor::AddXSLTParamNamespace(const nsString& aPrefix,
+ const nsString& aNamespace) {
+ RefPtr<nsAtom> pre = NS_Atomize(aPrefix);
+ return mParamNamespaceMap.mapNamespace(pre, aNamespace);
+}
+
+class txXSLTParamContext : public txIParseContext, public txIEvalContext {
+ public:
+ txXSLTParamContext(txNamespaceMap* aResolver, const txXPathNode& aContext,
+ txResultRecycler* aRecycler)
+ : mResolver(aResolver), mContext(aContext), mRecycler(aRecycler) {}
+
+ // txIParseContext
+ nsresult resolveNamespacePrefix(nsAtom* aPrefix, int32_t& aID) override {
+ aID = mResolver->lookupNamespace(aPrefix);
+ return aID == kNameSpaceID_Unknown ? NS_ERROR_DOM_NAMESPACE_ERR : NS_OK;
+ }
+ nsresult resolveFunctionCall(nsAtom* aName, int32_t aID,
+ FunctionCall** aFunction) override {
+ return NS_ERROR_XPATH_UNKNOWN_FUNCTION;
+ }
+ bool caseInsensitiveNameTests() override { return false; }
+ void SetErrorOffset(uint32_t aOffset) override {}
+
+ // txIEvalContext
+ nsresult getVariable(int32_t aNamespace, nsAtom* aLName,
+ txAExprResult*& aResult) override {
+ aResult = nullptr;
+ return NS_ERROR_INVALID_ARG;
+ }
+ nsresult isStripSpaceAllowed(const txXPathNode& aNode,
+ bool& aAllowed) override {
+ aAllowed = false;
+
+ return NS_OK;
+ }
+ void* getPrivateContext() override { return nullptr; }
+ txResultRecycler* recycler() override { return mRecycler; }
+ void receiveError(const nsAString& aMsg, nsresult aRes) override {}
+ const txXPathNode& getContextNode() override { return mContext; }
+ uint32_t size() override { return 1; }
+ uint32_t position() override { return 1; }
+
+ private:
+ txNamespaceMap* mResolver;
+ const txXPathNode& mContext;
+ txResultRecycler* mRecycler;
+};
+
+NS_IMETHODIMP
+txMozillaXSLTProcessor::AddXSLTParam(const nsString& aName,
+ const nsString& aNamespace,
+ const nsString& aSelect,
+ const nsString& aValue,
+ nsINode* aContext) {
+ nsresult rv = NS_OK;
+
+ if (aSelect.IsVoid() == aValue.IsVoid()) {
+ // Ignore if neither or both are specified
+ return NS_ERROR_FAILURE;
+ }
+
+ RefPtr<txAExprResult> value;
+ uint16_t resultType;
+ if (!aSelect.IsVoid()) {
+ // Set up context
+ UniquePtr<txXPathNode> contextNode(
+ txXPathNativeNode::createXPathNode(aContext));
+ NS_ENSURE_TRUE(contextNode, NS_ERROR_OUT_OF_MEMORY);
+
+ if (!mRecycler) {
+ mRecycler = new txResultRecycler;
+ }
+
+ txXSLTParamContext paramContext(&mParamNamespaceMap, *contextNode,
+ mRecycler);
+
+ // Parse
+ UniquePtr<Expr> expr;
+ rv = txExprParser::createExpr(aSelect, &paramContext,
+ getter_Transfers(expr));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // Evaluate
+ rv = expr->evaluate(&paramContext, getter_AddRefs(value));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ switch (value->getResultType()) {
+ case txAExprResult::NUMBER:
+ resultType = XPathResult::NUMBER_TYPE;
+ break;
+ case txAExprResult::STRING:
+ resultType = XPathResult::STRING_TYPE;
+ break;
+ case txAExprResult::BOOLEAN:
+ resultType = XPathResult::BOOLEAN_TYPE;
+ break;
+ case txAExprResult::NODESET:
+ resultType = XPathResult::UNORDERED_NODE_ITERATOR_TYPE;
+ break;
+ default:
+ MOZ_ASSERT_UNREACHABLE(
+ "We shouldn't have a txAExprResult::RESULT_TREE_FRAGMENT here.");
+ return NS_ERROR_FAILURE;
+ }
+ } else {
+ value = new StringResult(aValue, nullptr);
+ resultType = XPathResult::STRING_TYPE;
+ }
+
+ RefPtr<nsAtom> name = NS_Atomize(aName);
+ int32_t nsId = kNameSpaceID_Unknown;
+ rv = nsNameSpaceManager::GetInstance()->RegisterNameSpace(aNamespace, nsId);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ RefPtr<XPathResult> xpathResult = MakeRefPtr<XPathResult>(aContext);
+
+ ErrorResult error;
+ xpathResult->SetExprResult(value, resultType, aContext, error);
+ if (error.Failed()) {
+ return error.StealNSResult();
+ }
+
+ UniquePtr<OwningXSLTParameterValue> varValue =
+ MakeUnique<OwningXSLTParameterValue>();
+ varValue->SetAsXPathResult() = xpathResult.forget();
+
+ txExpandedName varName(nsId, name);
+ txVariable* var = static_cast<txVariable*>(mVariables.get(varName));
+ if (var) {
+ var->setValue(std::move(varValue));
+
+ return NS_OK;
+ }
+
+ var = new txVariable(std::move(varValue));
+
+ return mVariables.add(varName, var);
+}
+
+class nsTransformBlockerEvent : public mozilla::Runnable {
+ public:
+ RefPtr<txMozillaXSLTProcessor> mProcessor;
+
+ explicit nsTransformBlockerEvent(txMozillaXSLTProcessor* processor)
+ : mozilla::Runnable("nsTransformBlockerEvent"), mProcessor(processor) {}
+
+ ~nsTransformBlockerEvent() {
+ nsCOMPtr<Document> document =
+ mProcessor->GetSourceContentModel()->OwnerDoc();
+ document->UnblockOnload(true);
+ }
+
+ NS_IMETHOD Run() override {
+ mProcessor->TransformToDoc(nullptr, false);
+ return NS_OK;
+ }
+};
+
+nsresult txMozillaXSLTProcessor::DoTransform() {
+ NS_ENSURE_TRUE(mSource, NS_ERROR_UNEXPECTED);
+ NS_ENSURE_TRUE(mStylesheet, NS_ERROR_UNEXPECTED);
+ NS_ASSERTION(mObserver, "no observer");
+ NS_ASSERTION(NS_IsMainThread(), "should only be on main thread");
+
+ nsCOMPtr<nsIRunnable> event = new nsTransformBlockerEvent(this);
+ mSource->OwnerDoc()->BlockOnload();
+ nsresult rv = NS_DispatchToCurrentThread(event);
+ if (NS_FAILED(rv)) {
+ // XXX Maybe we should just display the source document in this case?
+ // Also, set up context information, see bug 204655.
+ reportError(rv, nullptr, nullptr);
+ }
+
+ return rv;
+}
+
+void txMozillaXSLTProcessor::ImportStylesheet(nsINode& aStyle,
+ mozilla::ErrorResult& aRv) {
+ // We don't support importing multiple stylesheets yet.
+ if (NS_WARN_IF(mStylesheetDocument || mStylesheet)) {
+ aRv.Throw(NS_ERROR_NOT_IMPLEMENTED);
+ return;
+ }
+
+ if (!nsContentUtils::SubjectPrincipalOrSystemIfNativeCaller()->Subsumes(
+ aStyle.NodePrincipal())) {
+ aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
+ return;
+ }
+
+ if (NS_WARN_IF(!aStyle.IsElement() && !aStyle.IsDocument())) {
+ aRv.Throw(NS_ERROR_INVALID_ARG);
+ return;
+ }
+
+ nsresult rv =
+ TX_CompileStylesheet(&aStyle, this, getter_AddRefs(mStylesheet));
+ // XXX set up exception context, bug 204658
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ aRv.Throw(rv);
+ return;
+ }
+
+ mStylesheetDocument = aStyle.OwnerDoc();
+ if (aStyle.IsElement()) {
+ mEmbeddedStylesheetRoot = aStyle.AsElement();
+ }
+
+ mStylesheetDocument->AddMutationObserver(this);
+}
+
+already_AddRefed<Document> txMozillaXSLTProcessor::TransformToDocument(
+ nsINode& aSource, ErrorResult& aRv) {
+ if (NS_WARN_IF(NS_FAILED(mCompileResult))) {
+ aRv.Throw(mCompileResult);
+ return nullptr;
+ }
+
+ if (!nsContentUtils::CanCallerAccess(&aSource)) {
+ aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
+ return nullptr;
+ }
+
+ nsresult rv = ensureStylesheet();
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ aRv.Throw(rv);
+ return nullptr;
+ }
+
+ mSource = &aSource;
+
+ nsCOMPtr<Document> doc;
+ rv = TransformToDoc(getter_AddRefs(doc), true);
+ if (NS_FAILED(rv)) {
+ aRv.Throw(rv);
+ return nullptr;
+ }
+ return doc.forget();
+}
+
+class XSLTProcessRequest final : public nsIRequest {
+ public:
+ explicit XSLTProcessRequest(txExecutionState* aState) : mState(aState) {}
+
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIREQUEST
+
+ void Done() { mState = nullptr; }
+
+ private:
+ ~XSLTProcessRequest() {}
+ txExecutionState* mState;
+};
+NS_IMPL_ISUPPORTS(XSLTProcessRequest, nsIRequest)
+
+NS_IMETHODIMP
+XSLTProcessRequest::GetName(nsACString& aResult) {
+ aResult.AssignLiteral("about:xslt-load-blocker");
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+XSLTProcessRequest::IsPending(bool* _retval) {
+ *_retval = true;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+XSLTProcessRequest::GetStatus(nsresult* status) {
+ *status = NS_OK;
+ return NS_OK;
+}
+
+NS_IMETHODIMP XSLTProcessRequest::SetCanceledReason(const nsACString& aReason) {
+ return SetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP XSLTProcessRequest::GetCanceledReason(nsACString& aReason) {
+ return GetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP XSLTProcessRequest::CancelWithReason(nsresult aStatus,
+ const nsACString& aReason) {
+ return CancelWithReasonImpl(aStatus, aReason);
+}
+
+NS_IMETHODIMP
+XSLTProcessRequest::Cancel(nsresult status) {
+ mState->stopProcessing();
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+XSLTProcessRequest::Suspend(void) { return NS_OK; }
+
+NS_IMETHODIMP
+XSLTProcessRequest::Resume(void) { return NS_OK; }
+
+NS_IMETHODIMP
+XSLTProcessRequest::GetLoadGroup(nsILoadGroup** aLoadGroup) {
+ *aLoadGroup = nullptr;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+XSLTProcessRequest::SetLoadGroup(nsILoadGroup* aLoadGroup) { return NS_OK; }
+
+NS_IMETHODIMP
+XSLTProcessRequest::GetLoadFlags(nsLoadFlags* aLoadFlags) {
+ *aLoadFlags = nsIRequest::LOAD_NORMAL;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+XSLTProcessRequest::SetLoadFlags(nsLoadFlags aLoadFlags) { return NS_OK; }
+
+NS_IMETHODIMP
+XSLTProcessRequest::GetTRRMode(nsIRequest::TRRMode* aTRRMode) {
+ return GetTRRModeImpl(aTRRMode);
+}
+
+NS_IMETHODIMP
+XSLTProcessRequest::SetTRRMode(nsIRequest::TRRMode aTRRMode) {
+ return SetTRRModeImpl(aTRRMode);
+}
+
+nsresult txMozillaXSLTProcessor::TransformToDoc(Document** aResult,
+ bool aCreateDataDocument) {
+ UniquePtr<txXPathNode> sourceNode(
+ txXPathNativeNode::createXPathNode(mSource));
+ if (!sourceNode) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ txExecutionState es(mStylesheet, IsLoadDisabled());
+
+ Document* sourceDoc = mSource->OwnerDoc();
+ nsCOMPtr<nsILoadGroup> loadGroup = sourceDoc->GetDocumentLoadGroup();
+ if (!loadGroup) {
+ nsCOMPtr<nsPIDOMWindowInner> win = do_QueryInterface(mOwner);
+ if (win && win->IsCurrentInnerWindow()) {
+ Document* doc = win->GetDoc();
+ if (doc) {
+ loadGroup = doc->GetDocumentLoadGroup();
+ }
+ }
+
+ if (!loadGroup) {
+ return NS_ERROR_FAILURE;
+ }
+ }
+
+ RefPtr<XSLTProcessRequest> xsltProcessRequest = new XSLTProcessRequest(&es);
+ loadGroup->AddRequest(xsltProcessRequest, nullptr);
+
+ // XXX Need to add error observers
+
+ // If aResult is non-null, we're a data document
+ txToDocHandlerFactory handlerFactory(&es, sourceDoc, mObserver,
+ aCreateDataDocument);
+ es.mOutputHandlerFactory = &handlerFactory;
+
+ nsresult rv = es.init(*sourceNode, &mVariables);
+
+ // Process root of XML source document
+ if (NS_SUCCEEDED(rv)) {
+ rv = txXSLTProcessor::execute(es);
+ }
+
+ xsltProcessRequest->Done();
+ loadGroup->RemoveRequest(xsltProcessRequest, nullptr, NS_OK);
+
+ nsresult endRv = es.end(rv);
+ if (NS_SUCCEEDED(rv)) {
+ rv = endRv;
+ }
+
+ if (NS_SUCCEEDED(rv)) {
+ if (aResult) {
+ txAOutputXMLEventHandler* handler =
+ static_cast<txAOutputXMLEventHandler*>(es.mOutputHandler);
+ nsCOMPtr<Document> doc;
+ handler->getOutputDocument(getter_AddRefs(doc));
+ MOZ_ASSERT(doc->GetReadyStateEnum() == Document::READYSTATE_INTERACTIVE,
+ "Bad readyState");
+ doc->SetReadyStateInternal(Document::READYSTATE_COMPLETE);
+ doc.forget(aResult);
+ }
+ } else if (mObserver) {
+ // XXX set up context information, bug 204655
+ reportError(rv, nullptr, nullptr);
+ }
+
+ return rv;
+}
+
+already_AddRefed<DocumentFragment> txMozillaXSLTProcessor::TransformToFragment(
+ nsINode& aSource, Document& aOutput, ErrorResult& aRv) {
+ if (NS_WARN_IF(NS_FAILED(mCompileResult))) {
+ aRv.Throw(mCompileResult);
+ return nullptr;
+ }
+
+ nsIPrincipal* subject =
+ nsContentUtils::SubjectPrincipalOrSystemIfNativeCaller();
+ if (!subject->Subsumes(aSource.NodePrincipal()) ||
+ !subject->Subsumes(aOutput.NodePrincipal())) {
+ aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
+ return nullptr;
+ }
+
+ nsresult rv = ensureStylesheet();
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ aRv.Throw(rv);
+ return nullptr;
+ }
+
+ UniquePtr<txXPathNode> sourceNode(
+ txXPathNativeNode::createXPathNode(&aSource));
+ if (!sourceNode) {
+ aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
+ return nullptr;
+ }
+
+ txExecutionState es(mStylesheet, IsLoadDisabled());
+
+ // XXX Need to add error observers
+
+ RefPtr<DocumentFragment> frag = aOutput.CreateDocumentFragment();
+ txToFragmentHandlerFactory handlerFactory(frag);
+ es.mOutputHandlerFactory = &handlerFactory;
+
+ rv = es.init(*sourceNode, &mVariables);
+
+ // Process root of XML source document
+ if (NS_SUCCEEDED(rv)) {
+ rv = txXSLTProcessor::execute(es);
+ }
+ // XXX setup exception context, bug 204658
+ nsresult endRv = es.end(rv);
+ if (NS_SUCCEEDED(rv)) {
+ rv = endRv;
+ }
+
+ if (NS_FAILED(rv)) {
+ aRv.Throw(rv);
+ return nullptr;
+ }
+
+ return frag.forget();
+}
+
+void txMozillaXSLTProcessor::SetParameter(const nsAString& aNamespaceURI,
+ const nsAString& aLocalName,
+ const XSLTParameterValue& aValue,
+ ErrorResult& aError) {
+ if (aValue.IsNode()) {
+ if (!nsContentUtils::CanCallerAccess(&aValue.GetAsNode())) {
+ aError.ThrowSecurityError("Caller is not allowed to access node.");
+ return;
+ }
+ } else if (aValue.IsNodeSequence()) {
+ const Sequence<OwningNonNull<nsINode>>& values = aValue.GetAsNodeSequence();
+ for (const auto& node : values) {
+ if (!nsContentUtils::CanCallerAccess(node.get())) {
+ aError.ThrowSecurityError(
+ "Caller is not allowed to access node in sequence.");
+ return;
+ }
+ }
+ } else if (aValue.IsXPathResult()) {
+ XPathResult& xpathResult = aValue.GetAsXPathResult();
+ RefPtr<txAExprResult> result;
+ aError = xpathResult.GetExprResult(getter_AddRefs(result));
+ if (aError.Failed()) {
+ return;
+ }
+
+ if (result->getResultType() == txAExprResult::NODESET) {
+ txNodeSet* nodeSet =
+ static_cast<txNodeSet*>(static_cast<txAExprResult*>(result));
+
+ int32_t i, count = nodeSet->size();
+ for (i = 0; i < count; ++i) {
+ nsINode* node = txXPathNativeNode::getNode(nodeSet->get(i));
+ if (!nsContentUtils::CanCallerAccess(node)) {
+ aError.ThrowSecurityError(
+ "Caller is not allowed to access node in node-set.");
+ return;
+ }
+ }
+ }
+ }
+
+ int32_t nsId = kNameSpaceID_Unknown;
+ aError =
+ nsNameSpaceManager::GetInstance()->RegisterNameSpace(aNamespaceURI, nsId);
+ if (aError.Failed()) {
+ return;
+ }
+
+ RefPtr<nsAtom> localName = NS_Atomize(aLocalName);
+ txExpandedName varName(nsId, localName);
+
+ UniquePtr<OwningXSLTParameterValue> value =
+ txVariable::convertToOwning(aValue, aError);
+ if (aError.Failed()) {
+ return;
+ }
+
+ txVariable* var = static_cast<txVariable*>(mVariables.get(varName));
+ if (var) {
+ var->setValue(std::move(value));
+ return;
+ }
+
+ UniquePtr<txVariable> newVar = MakeUnique<txVariable>(std::move(value));
+ mVariables.add(varName, newVar.release());
+}
+
+void txMozillaXSLTProcessor::GetParameter(
+ const nsAString& aNamespaceURI, const nsAString& aLocalName,
+ Nullable<OwningXSLTParameterValue>& aValue, ErrorResult& aRv) {
+ int32_t nsId = kNameSpaceID_Unknown;
+ nsresult rv =
+ nsNameSpaceManager::GetInstance()->RegisterNameSpace(aNamespaceURI, nsId);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ aRv.Throw(rv);
+ return;
+ }
+ RefPtr<nsAtom> localName = NS_Atomize(aLocalName);
+ txExpandedName varName(nsId, localName);
+
+ txVariable* var = static_cast<txVariable*>(mVariables.get(varName));
+ if (!var) {
+ return;
+ }
+
+ aValue.SetValue(var->getUnionValue());
+}
+
+void txMozillaXSLTProcessor::RemoveParameter(const nsAString& aNamespaceURI,
+ const nsAString& aLocalName,
+ ErrorResult& aRv) {
+ int32_t nsId = kNameSpaceID_Unknown;
+ nsresult rv =
+ nsNameSpaceManager::GetInstance()->RegisterNameSpace(aNamespaceURI, nsId);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ aRv.Throw(rv);
+ return;
+ }
+ RefPtr<nsAtom> localName = NS_Atomize(aLocalName);
+ txExpandedName varName(nsId, localName);
+
+ mVariables.remove(varName);
+}
+
+void txMozillaXSLTProcessor::ClearParameters() { mVariables.clear(); }
+
+void txMozillaXSLTProcessor::Reset() {
+ if (mStylesheetDocument) {
+ mStylesheetDocument->RemoveMutationObserver(this);
+ }
+ mStylesheet = nullptr;
+ mStylesheetDocument = nullptr;
+ mEmbeddedStylesheetRoot = nullptr;
+ mCompileResult = NS_OK;
+ mVariables.clear();
+}
+
+void txMozillaXSLTProcessor::SetFlags(uint32_t aFlags, SystemCallerGuarantee) {
+ mFlags = aFlags;
+}
+
+uint32_t txMozillaXSLTProcessor::Flags(SystemCallerGuarantee) { return mFlags; }
+
+NS_IMETHODIMP
+txMozillaXSLTProcessor::LoadStyleSheet(nsIURI* aUri,
+ Document* aLoaderDocument) {
+ mozilla::dom::ReferrerPolicy refpol = mozilla::dom::ReferrerPolicy::_empty;
+ if (mStylesheetDocument) {
+ refpol = mStylesheetDocument->GetReferrerPolicy();
+ }
+
+ nsresult rv = TX_LoadSheet(aUri, this, aLoaderDocument, refpol);
+ if (NS_FAILED(rv) && mObserver) {
+ // This is most likely a network or security error, just
+ // use the uri as context.
+ nsAutoCString spec;
+ aUri->GetSpec(spec);
+ CopyUTF8toUTF16(spec, mSourceText);
+ nsresult status = NS_ERROR_GET_MODULE(rv) == NS_ERROR_MODULE_XSLT
+ ? rv
+ : NS_ERROR_XSLT_NETWORK_ERROR;
+ reportError(status, nullptr, nullptr);
+ }
+ return rv;
+}
+
+nsresult txMozillaXSLTProcessor::setStylesheet(txStylesheet* aStylesheet) {
+ mStylesheet = aStylesheet;
+ if (mSource) {
+ return DoTransform();
+ }
+ return NS_OK;
+}
+
+void txMozillaXSLTProcessor::reportError(nsresult aResult,
+ const char16_t* aErrorText,
+ const char16_t* aSourceText) {
+ if (!mObserver) {
+ return;
+ }
+
+ mTransformResult = aResult;
+
+ if (aErrorText) {
+ mErrorText.Assign(aErrorText);
+ } else {
+ nsCOMPtr<nsIStringBundleService> sbs =
+ mozilla::components::StringBundle::Service();
+ if (sbs) {
+ nsString errorText;
+ sbs->FormatStatusMessage(aResult, u"", errorText);
+
+ nsAutoString errorMessage;
+ nsCOMPtr<nsIStringBundle> bundle;
+ sbs->CreateBundle(XSLT_MSGS_URL, getter_AddRefs(bundle));
+
+ if (bundle) {
+ AutoTArray<nsString, 1> error = {errorText};
+ if (mStylesheet) {
+ bundle->FormatStringFromName("TransformError", error, errorMessage);
+ } else {
+ bundle->FormatStringFromName("LoadingError", error, errorMessage);
+ }
+ }
+ mErrorText.Assign(errorMessage);
+ }
+ }
+
+ if (aSourceText) {
+ mSourceText.Assign(aSourceText);
+ }
+
+ if (mSource) {
+ notifyError();
+ }
+}
+
+void txMozillaXSLTProcessor::notifyError() {
+ nsCOMPtr<Document> document;
+ {
+ nsresult rv = NS_NewXMLDocument(getter_AddRefs(document));
+ NS_ENSURE_SUCCESS_VOID(rv);
+ }
+
+ URIUtils::ResetWithSource(document, mSource);
+
+ MOZ_ASSERT(
+ document->GetReadyStateEnum() == Document::READYSTATE_UNINITIALIZED,
+ "Bad readyState.");
+ document->SetReadyStateInternal(Document::READYSTATE_LOADING);
+
+ constexpr auto ns =
+ u"http://www.mozilla.org/newlayout/xml/parsererror.xml"_ns;
+
+ IgnoredErrorResult rv;
+ ElementCreationOptionsOrString options;
+ options.SetAsString();
+
+ nsCOMPtr<Element> element =
+ document->CreateElementNS(ns, u"parsererror"_ns, options, rv);
+ if (rv.Failed()) {
+ return;
+ }
+
+ document->AppendChild(*element, rv);
+ if (rv.Failed()) {
+ return;
+ }
+
+ RefPtr<nsTextNode> text = document->CreateTextNode(mErrorText);
+
+ element->AppendChild(*text, rv);
+ if (rv.Failed()) {
+ return;
+ }
+
+ if (!mSourceText.IsEmpty()) {
+ ElementCreationOptionsOrString options;
+ options.SetAsString();
+
+ nsCOMPtr<Element> sourceElement =
+ document->CreateElementNS(ns, u"sourcetext"_ns, options, rv);
+ if (rv.Failed()) {
+ return;
+ }
+
+ element->AppendChild(*sourceElement, rv);
+ if (rv.Failed()) {
+ return;
+ }
+
+ text = document->CreateTextNode(mSourceText);
+
+ sourceElement->AppendChild(*text, rv);
+ if (rv.Failed()) {
+ return;
+ }
+ }
+
+ MOZ_ASSERT(document->GetReadyStateEnum() == Document::READYSTATE_LOADING,
+ "Bad readyState.");
+ document->SetReadyStateInternal(Document::READYSTATE_INTERACTIVE);
+ mObserver->OnTransformDone(mSource->OwnerDoc(), mTransformResult, document);
+}
+
+nsresult txMozillaXSLTProcessor::ensureStylesheet() {
+ if (mStylesheet) {
+ return NS_OK;
+ }
+
+ NS_ENSURE_TRUE(mStylesheetDocument, NS_ERROR_NOT_INITIALIZED);
+
+ nsINode* style = mEmbeddedStylesheetRoot;
+ if (!style) {
+ style = mStylesheetDocument;
+ }
+
+ return TX_CompileStylesheet(style, this, getter_AddRefs(mStylesheet));
+}
+
+void txMozillaXSLTProcessor::NodeWillBeDestroyed(nsINode* aNode) {
+ nsCOMPtr<nsIMutationObserver> kungFuDeathGrip(this);
+ if (NS_FAILED(mCompileResult)) {
+ return;
+ }
+
+ mCompileResult = ensureStylesheet();
+ mStylesheetDocument = nullptr;
+ mEmbeddedStylesheetRoot = nullptr;
+}
+
+void txMozillaXSLTProcessor::CharacterDataChanged(
+ nsIContent* aContent, const CharacterDataChangeInfo&) {
+ mStylesheet = nullptr;
+}
+
+void txMozillaXSLTProcessor::AttributeChanged(Element* aElement,
+ int32_t aNameSpaceID,
+ nsAtom* aAttribute,
+ int32_t aModType,
+ const nsAttrValue* aOldValue) {
+ mStylesheet = nullptr;
+}
+
+void txMozillaXSLTProcessor::ContentAppended(nsIContent* aFirstNewContent) {
+ mStylesheet = nullptr;
+}
+
+void txMozillaXSLTProcessor::ContentInserted(nsIContent* aChild) {
+ mStylesheet = nullptr;
+}
+
+void txMozillaXSLTProcessor::ContentRemoved(nsIContent* aChild,
+ nsIContent* aPreviousSibling) {
+ mStylesheet = nullptr;
+}
+
+/* virtual */
+JSObject* txMozillaXSLTProcessor::WrapObject(
+ JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
+ return XSLTProcessor_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+DocGroup* txMozillaXSLTProcessor::GetDocGroup() const {
+ return mStylesheetDocument ? mStylesheetDocument->GetDocGroup() : nullptr;
+}
+
+/* static */
+already_AddRefed<txMozillaXSLTProcessor> txMozillaXSLTProcessor::Constructor(
+ const GlobalObject& aGlobal) {
+ RefPtr<txMozillaXSLTProcessor> processor =
+ new txMozillaXSLTProcessor(aGlobal.GetAsSupports());
+ return processor.forget();
+}
+
+/* static*/
+nsresult txMozillaXSLTProcessor::Startup() {
+ if (!txXSLTProcessor::init()) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ return NS_OK;
+}
+
+/* static*/
+void txMozillaXSLTProcessor::Shutdown() { txXSLTProcessor::shutdown(); }
+
+/* static */
+UniquePtr<txVariable::OwningXSLTParameterValue> txVariable::convertToOwning(
+ const XSLTParameterValue& aValue, ErrorResult& aError) {
+ UniquePtr<OwningXSLTParameterValue> value =
+ MakeUnique<OwningXSLTParameterValue>();
+ if (aValue.IsUnrestrictedDouble()) {
+ value->SetAsUnrestrictedDouble() = aValue.GetAsUnrestrictedDouble();
+ } else if (aValue.IsBoolean()) {
+ value->SetAsBoolean() = aValue.GetAsBoolean();
+ } else if (aValue.IsString()) {
+ value->SetAsString() = aValue.GetAsString();
+ } else if (aValue.IsNode()) {
+ value->SetAsNode() = aValue.GetAsNode();
+ } else if (aValue.IsNodeSequence()) {
+ value->SetAsNodeSequence() = aValue.GetAsNodeSequence();
+ } else if (aValue.IsXPathResult()) {
+ // Clone the XPathResult so that mutations don't affect this variable.
+ RefPtr<XPathResult> clone = aValue.GetAsXPathResult().Clone(aError);
+ if (aError.Failed()) {
+ return nullptr;
+ }
+ value->SetAsXPathResult() = *clone;
+ } else {
+ MOZ_ASSERT(false, "Unknown type?");
+ }
+ return value;
+}
+
+/* static */
+nsresult txVariable::convert(const OwningXSLTParameterValue& aUnionValue,
+ txAExprResult** aValue) {
+ if (aUnionValue.IsUnrestrictedDouble()) {
+ NS_ADDREF(*aValue = new NumberResult(aUnionValue.GetAsUnrestrictedDouble(),
+ nullptr));
+ return NS_OK;
+ }
+
+ if (aUnionValue.IsBoolean()) {
+ NS_ADDREF(*aValue = new BooleanResult(aUnionValue.GetAsBoolean()));
+ return NS_OK;
+ }
+
+ if (aUnionValue.IsString()) {
+ NS_ADDREF(*aValue = new StringResult(aUnionValue.GetAsString(), nullptr));
+ return NS_OK;
+ }
+
+ if (aUnionValue.IsNode()) {
+ nsINode& node = aUnionValue.GetAsNode();
+ UniquePtr<txXPathNode> xpathNode(txXPathNativeNode::createXPathNode(&node));
+ if (!xpathNode) {
+ return NS_ERROR_FAILURE;
+ }
+
+ NS_ADDREF(*aValue = new txNodeSet(*xpathNode, nullptr));
+ return NS_OK;
+ }
+
+ if (aUnionValue.IsNodeSequence()) {
+ RefPtr<txNodeSet> nodeSet(new txNodeSet(nullptr));
+ const Sequence<OwningNonNull<nsINode>>& values =
+ aUnionValue.GetAsNodeSequence();
+ for (const auto& node : values) {
+ UniquePtr<txXPathNode> xpathNode(
+ txXPathNativeNode::createXPathNode(node.get()));
+ if (!xpathNode) {
+ return NS_ERROR_FAILURE;
+ }
+
+ nodeSet->append(*xpathNode);
+ }
+ nodeSet.forget(aValue);
+ return NS_OK;
+ }
+
+ MOZ_ASSERT(aUnionValue.IsXPathResult());
+
+ XPathResult& xpathResult = aUnionValue.GetAsXPathResult();
+ if (xpathResult.ResultType() == XPathResult::NUMBER_TYPE) {
+ IgnoredErrorResult rv;
+ NS_ADDREF(*aValue =
+ new NumberResult(xpathResult.GetNumberValue(rv), nullptr));
+ MOZ_ASSERT(!rv.Failed());
+ return NS_OK;
+ }
+
+ if (xpathResult.ResultType() == XPathResult::BOOLEAN_TYPE) {
+ IgnoredErrorResult rv;
+ NS_ADDREF(*aValue = new BooleanResult(xpathResult.GetBooleanValue(rv)));
+ MOZ_ASSERT(!rv.Failed());
+ return NS_OK;
+ }
+
+ if (xpathResult.ResultType() == XPathResult::STRING_TYPE) {
+ IgnoredErrorResult rv;
+ nsString value;
+ xpathResult.GetStringValue(value, rv);
+ NS_ADDREF(*aValue = new StringResult(value, nullptr));
+ MOZ_ASSERT(!rv.Failed());
+ return NS_OK;
+ }
+
+ // If the XPathResult holds a nodeset, then it will keep the nodes alive and
+ // we'll hold the XPathResult alive.
+ return xpathResult.GetExprResult(aValue);
+}
diff --git a/dom/xslt/xslt/txMozillaXSLTProcessor.h b/dom/xslt/xslt/txMozillaXSLTProcessor.h
new file mode 100644
index 0000000000..b000f804c6
--- /dev/null
+++ b/dom/xslt/xslt/txMozillaXSLTProcessor.h
@@ -0,0 +1,170 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef TRANSFRMX_TXMOZILLAXSLTPROCESSOR_H
+#define TRANSFRMX_TXMOZILLAXSLTPROCESSOR_H
+
+#include "nsStubMutationObserver.h"
+#include "nsIDocumentTransformer.h"
+#include "txExpandedNameMap.h"
+#include "txNamespaceMap.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsWrapperCache.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/dom/BindingDeclarations.h"
+#include "mozilla/dom/XSLTProcessorBinding.h"
+
+class nsINode;
+class nsIURI;
+class nsIVariant;
+class txStylesheet;
+class txResultRecycler;
+class txIGlobalParameter;
+
+namespace mozilla {
+class ErrorResult;
+
+namespace dom {
+
+class DocGroup;
+class Document;
+class DocumentFragment;
+class GlobalObject;
+enum class ReferrerPolicy : uint8_t;
+} // namespace dom
+} // namespace mozilla
+
+/**
+ * txMozillaXSLTProcessor is a front-end to the XSLT Processor.
+ */
+class txMozillaXSLTProcessor final : public nsIDocumentTransformer,
+ public nsStubMutationObserver,
+ public nsWrapperCache {
+ public:
+ typedef mozilla::dom::
+ UnrestrictedDoubleOrBooleanOrStringOrNodeOrNodeSequenceOrXPathResult
+ XSLTParameterValue;
+ typedef mozilla::dom::
+ OwningUnrestrictedDoubleOrBooleanOrStringOrNodeOrNodeSequenceOrXPathResult
+ OwningXSLTParameterValue;
+
+ /**
+ * Creates a new txMozillaXSLTProcessor
+ */
+ txMozillaXSLTProcessor();
+
+ // nsISupports interface
+ NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+ NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS_AMBIGUOUS(txMozillaXSLTProcessor,
+ nsIDocumentTransformer)
+
+ // nsIDocumentTransformer interface
+ NS_IMETHOD SetTransformObserver(nsITransformObserver* aObserver) override;
+ NS_IMETHOD LoadStyleSheet(nsIURI* aUri,
+ mozilla::dom::Document* aLoaderDocument) override;
+ NS_IMETHOD SetSourceContentModel(nsINode* aSource) override;
+ NS_IMETHOD CancelLoads() override { return NS_OK; }
+ NS_IMETHOD AddXSLTParamNamespace(const nsString& aPrefix,
+ const nsString& aNamespace) override;
+ NS_IMETHOD AddXSLTParam(const nsString& aName, const nsString& aNamespace,
+ const nsString& aSelect, const nsString& aValue,
+ nsINode* aContext) override;
+
+ // nsIMutationObserver interface
+ NS_DECL_NSIMUTATIONOBSERVER_CHARACTERDATACHANGED
+ NS_DECL_NSIMUTATIONOBSERVER_ATTRIBUTECHANGED
+ NS_DECL_NSIMUTATIONOBSERVER_CONTENTAPPENDED
+ NS_DECL_NSIMUTATIONOBSERVER_CONTENTINSERTED
+ NS_DECL_NSIMUTATIONOBSERVER_CONTENTREMOVED
+ NS_DECL_NSIMUTATIONOBSERVER_NODEWILLBEDESTROYED
+
+ // nsWrapperCache
+ virtual JSObject* WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) override;
+
+ // WebIDL
+ nsISupports* GetParentObject() const { return mOwner; }
+
+ mozilla::dom::DocGroup* GetDocGroup() const;
+
+ static already_AddRefed<txMozillaXSLTProcessor> Constructor(
+ const mozilla::dom::GlobalObject& aGlobal);
+
+ void ImportStylesheet(nsINode& stylesheet, mozilla::ErrorResult& aRv);
+ already_AddRefed<mozilla::dom::DocumentFragment> TransformToFragment(
+ nsINode& source, mozilla::dom::Document& docVal,
+ mozilla::ErrorResult& aRv);
+ already_AddRefed<mozilla::dom::Document> TransformToDocument(
+ nsINode& source, mozilla::ErrorResult& aRv);
+
+ void SetParameter(const nsAString& aNamespaceURI, const nsAString& aLocalName,
+ const XSLTParameterValue& aValue,
+ mozilla::ErrorResult& aError);
+ void GetParameter(const nsAString& aNamespaceURI, const nsAString& aLocalName,
+ mozilla::dom::Nullable<OwningXSLTParameterValue>& aValue,
+ mozilla::ErrorResult& aRv);
+ void RemoveParameter(const nsAString& aNamespaceURI,
+ const nsAString& aLocalName, mozilla::ErrorResult& aRv);
+ void ClearParameters();
+ void Reset();
+
+ uint32_t Flags(mozilla::dom::SystemCallerGuarantee);
+ void SetFlags(uint32_t aFlags, mozilla::dom::SystemCallerGuarantee);
+
+ nsresult setStylesheet(txStylesheet* aStylesheet);
+ void reportError(nsresult aResult, const char16_t* aErrorText,
+ const char16_t* aSourceText);
+
+ nsINode* GetSourceContentModel() { return mSource; }
+
+ nsresult TransformToDoc(mozilla::dom::Document** aResult,
+ bool aCreateDataDocument);
+
+ bool IsLoadDisabled() {
+ return (mFlags & mozilla::dom::XSLTProcessor_Binding::DISABLE_ALL_LOADS) !=
+ 0;
+ }
+
+ static nsresult Startup();
+ static void Shutdown();
+
+ private:
+ explicit txMozillaXSLTProcessor(nsISupports* aOwner);
+ /**
+ * Default destructor for txMozillaXSLTProcessor
+ */
+ ~txMozillaXSLTProcessor();
+
+ nsresult DoTransform();
+ void notifyError();
+ nsresult ensureStylesheet();
+
+ nsCOMPtr<nsISupports> mOwner;
+
+ RefPtr<txStylesheet> mStylesheet;
+ mozilla::dom::Document* mStylesheetDocument; // weak
+ nsCOMPtr<nsIContent> mEmbeddedStylesheetRoot;
+
+ nsCOMPtr<nsINode> mSource;
+ nsresult mTransformResult;
+ nsresult mCompileResult;
+ nsString mErrorText, mSourceText;
+ nsCOMPtr<nsITransformObserver> mObserver;
+ txOwningExpandedNameMap<txIGlobalParameter> mVariables;
+ txNamespaceMap mParamNamespaceMap;
+ RefPtr<txResultRecycler> mRecycler;
+
+ uint32_t mFlags;
+};
+
+extern nsresult TX_LoadSheet(nsIURI* aUri, txMozillaXSLTProcessor* aProcessor,
+ mozilla::dom::Document* aLoaderDocument,
+ mozilla::dom::ReferrerPolicy aReferrerPolicy);
+
+extern nsresult TX_CompileStylesheet(nsINode* aNode,
+ txMozillaXSLTProcessor* aProcessor,
+ txStylesheet** aStylesheet);
+
+#endif
diff --git a/dom/xslt/xslt/txNodeSorter.cpp b/dom/xslt/xslt/txNodeSorter.cpp
new file mode 100644
index 0000000000..05a0d97957
--- /dev/null
+++ b/dom/xslt/xslt/txNodeSorter.cpp
@@ -0,0 +1,240 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txNodeSorter.h"
+#include "txExecutionState.h"
+#include "txXPathResultComparator.h"
+#include "nsGkAtoms.h"
+#include "txNodeSetContext.h"
+#include "txExpr.h"
+#include "txStringUtils.h"
+#include "nsQuickSort.h"
+
+#include "mozilla/CheckedInt.h"
+#include "mozilla/UniquePtrExtensions.h"
+
+using mozilla::CheckedUint32;
+using mozilla::MakeUnique;
+using mozilla::MakeUniqueFallible;
+using mozilla::UniquePtr;
+
+/*
+ * Sorts Nodes as specified by the W3C XSLT 1.0 Recommendation
+ */
+
+txNodeSorter::txNodeSorter() : mNKeys(0) {}
+
+txNodeSorter::~txNodeSorter() {
+ txListIterator iter(&mSortKeys);
+ while (iter.hasNext()) {
+ SortKey* key = (SortKey*)iter.next();
+ delete key->mComparator;
+ delete key;
+ }
+}
+
+nsresult txNodeSorter::addSortElement(Expr* aSelectExpr, Expr* aLangExpr,
+ Expr* aDataTypeExpr, Expr* aOrderExpr,
+ Expr* aCaseOrderExpr,
+ txIEvalContext* aContext) {
+ UniquePtr<SortKey> key(new SortKey);
+ nsresult rv = NS_OK;
+
+ // Select
+ key->mExpr = aSelectExpr;
+
+ // Order
+ bool ascending = true;
+ if (aOrderExpr) {
+ nsAutoString attrValue;
+ rv = aOrderExpr->evaluateToString(aContext, attrValue);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (TX_StringEqualsAtom(attrValue, nsGkAtoms::descending)) {
+ ascending = false;
+ } else if (!TX_StringEqualsAtom(attrValue, nsGkAtoms::ascending)) {
+ // XXX ErrorReport: unknown value for order attribute
+ return NS_ERROR_XSLT_BAD_VALUE;
+ }
+ }
+
+ // Create comparator depending on datatype
+ nsAutoString dataType;
+ if (aDataTypeExpr) {
+ rv = aDataTypeExpr->evaluateToString(aContext, dataType);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ if (!aDataTypeExpr || TX_StringEqualsAtom(dataType, nsGkAtoms::text)) {
+ // Text comparator
+
+ // Language
+ nsAutoString lang;
+ if (aLangExpr) {
+ rv = aLangExpr->evaluateToString(aContext, lang);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ // Case-order
+ bool upperFirst = false;
+ if (aCaseOrderExpr) {
+ nsAutoString attrValue;
+
+ rv = aCaseOrderExpr->evaluateToString(aContext, attrValue);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (TX_StringEqualsAtom(attrValue, nsGkAtoms::upperFirst)) {
+ upperFirst = true;
+ } else if (!TX_StringEqualsAtom(attrValue, nsGkAtoms::lowerFirst)) {
+ // XXX ErrorReport: unknown value for case-order attribute
+ return NS_ERROR_XSLT_BAD_VALUE;
+ }
+ }
+
+ key->mComparator =
+ new txResultStringComparator(ascending, upperFirst, lang);
+ } else if (TX_StringEqualsAtom(dataType, nsGkAtoms::number)) {
+ // Number comparator
+ key->mComparator = new txResultNumberComparator(ascending);
+ } else {
+ // XXX ErrorReport: unknown data-type
+ return NS_ERROR_XSLT_BAD_VALUE;
+ }
+
+ // mSortKeys owns key now.
+ mSortKeys.add(key.release());
+ mNKeys++;
+
+ return NS_OK;
+}
+
+nsresult txNodeSorter::sortNodeSet(txNodeSet* aNodes, txExecutionState* aEs,
+ txNodeSet** aResult) {
+ if (mNKeys == 0 || aNodes->isEmpty()) {
+ RefPtr<txNodeSet> ref(aNodes);
+ ref.forget(aResult);
+
+ return NS_OK;
+ }
+
+ *aResult = nullptr;
+
+ RefPtr<txNodeSet> sortedNodes;
+ nsresult rv = aEs->recycler()->getNodeSet(getter_AddRefs(sortedNodes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // Create and set up memoryblock for sort-values and indexarray
+ CheckedUint32 len = aNodes->size();
+ CheckedUint32 numSortValues = len * mNKeys;
+ CheckedUint32 sortValuesSize = numSortValues * sizeof(txObject*);
+ if (!sortValuesSize.isValid()) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ auto indexes = MakeUniqueFallible<uint32_t[]>(len.value());
+ auto sortValues = MakeUniqueFallible<txObject*[]>(numSortValues.value());
+ if (!indexes || !sortValues) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ uint32_t i;
+ for (i = 0; i < len.value(); ++i) {
+ indexes[i] = i;
+ }
+ memset(sortValues.get(), 0, sortValuesSize.value());
+
+ auto nodeSetContext = MakeUnique<txNodeSetContext>(aNodes, aEs);
+
+ // Sort the indexarray
+ SortData sortData;
+ sortData.mNodeSorter = this;
+ sortData.mContext = nodeSetContext.get();
+ sortData.mSortValues = sortValues.get();
+ sortData.mRv = NS_OK;
+
+ aEs->pushEvalContext(nodeSetContext.release());
+
+ NS_QuickSort(indexes.get(), len.value(), sizeof(uint32_t), compareNodes,
+ &sortData);
+
+ // Delete these here so we don't have to deal with them at every possible
+ // failurepoint
+ for (i = 0; i < numSortValues.value(); ++i) {
+ delete sortValues[i];
+ }
+
+ if (NS_FAILED(sortData.mRv)) {
+ // The txExecutionState owns the evalcontext so no need to handle it
+ return sortData.mRv;
+ }
+
+ // Insert nodes in sorted order in new nodeset
+ for (i = 0; i < len.value(); ++i) {
+ rv = sortedNodes->append(aNodes->get(indexes[i]));
+ if (NS_FAILED(rv)) {
+ // The txExecutionState owns the evalcontext so no need to handle it
+ return rv;
+ }
+ }
+
+ delete aEs->popEvalContext();
+
+ sortedNodes.forget(aResult);
+
+ return NS_OK;
+}
+
+// static
+int txNodeSorter::compareNodes(const void* aIndexA, const void* aIndexB,
+ void* aSortData) {
+ SortData* sortData = static_cast<SortData*>(aSortData);
+ NS_ENSURE_SUCCESS(sortData->mRv, -1);
+
+ txListIterator iter(&sortData->mNodeSorter->mSortKeys);
+ uint32_t indexA = *static_cast<const uint32_t*>(aIndexA);
+ uint32_t indexB = *static_cast<const uint32_t*>(aIndexB);
+ txObject** sortValuesA =
+ sortData->mSortValues + indexA * sortData->mNodeSorter->mNKeys;
+ txObject** sortValuesB =
+ sortData->mSortValues + indexB * sortData->mNodeSorter->mNKeys;
+
+ unsigned int i;
+ // Step through each key until a difference is found
+ for (i = 0; i < sortData->mNodeSorter->mNKeys; ++i) {
+ SortKey* key = (SortKey*)iter.next();
+ // Lazy create sort values
+ if (!sortValuesA[i] &&
+ !calcSortValue(sortValuesA[i], key, sortData, indexA)) {
+ return -1;
+ }
+ if (!sortValuesB[i] &&
+ !calcSortValue(sortValuesB[i], key, sortData, indexB)) {
+ return -1;
+ }
+
+ // Compare node values
+ int compRes =
+ key->mComparator->compareValues(sortValuesA[i], sortValuesB[i]);
+ if (compRes != 0) return compRes;
+ }
+ // All keys have the same value for these nodes
+
+ return indexA - indexB;
+}
+
+// static
+bool txNodeSorter::calcSortValue(txObject*& aSortValue, SortKey* aKey,
+ SortData* aSortData, uint32_t aNodeIndex) {
+ aSortData->mContext->setPosition(aNodeIndex + 1); // position is 1-based
+
+ nsresult rv = aKey->mComparator->createSortableValue(
+ aKey->mExpr, aSortData->mContext, aSortValue);
+ if (NS_FAILED(rv)) {
+ aSortData->mRv = rv;
+ return false;
+ }
+
+ return true;
+}
diff --git a/dom/xslt/xslt/txNodeSorter.h b/dom/xslt/xslt/txNodeSorter.h
new file mode 100644
index 0000000000..c175e5e2fe
--- /dev/null
+++ b/dom/xslt/xslt/txNodeSorter.h
@@ -0,0 +1,55 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef TRANSFRMX_NODESORTER_H
+#define TRANSFRMX_NODESORTER_H
+
+#include "txCore.h"
+#include "txList.h"
+
+class Expr;
+class txExecutionState;
+class txNodeSet;
+class txObject;
+class txXPathResultComparator;
+class txIEvalContext;
+class txNodeSetContext;
+
+/*
+ * Sorts Nodes as specified by the W3C XSLT 1.0 Recommendation
+ */
+
+class txNodeSorter {
+ public:
+ txNodeSorter();
+ ~txNodeSorter();
+
+ nsresult addSortElement(Expr* aSelectExpr, Expr* aLangExpr,
+ Expr* aDataTypeExpr, Expr* aOrderExpr,
+ Expr* aCaseOrderExpr, txIEvalContext* aContext);
+ nsresult sortNodeSet(txNodeSet* aNodes, txExecutionState* aEs,
+ txNodeSet** aResult);
+
+ private:
+ struct SortData {
+ txNodeSorter* mNodeSorter;
+ txNodeSetContext* mContext;
+ txObject** mSortValues;
+ nsresult mRv;
+ };
+ struct SortKey {
+ Expr* mExpr;
+ txXPathResultComparator* mComparator;
+ };
+
+ static int compareNodes(const void* aIndexA, const void* aIndexB,
+ void* aSortData);
+ static bool calcSortValue(txObject*& aSortValue, SortKey* aKey,
+ SortData* aSortData, uint32_t aNodeIndex);
+ txList mSortKeys;
+ unsigned int mNKeys;
+};
+
+#endif
diff --git a/dom/xslt/xslt/txOutputFormat.cpp b/dom/xslt/xslt/txOutputFormat.cpp
new file mode 100644
index 0000000000..fe4d068f6e
--- /dev/null
+++ b/dom/xslt/xslt/txOutputFormat.cpp
@@ -0,0 +1,101 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txOutputFormat.h"
+#include "txXMLUtils.h"
+#include "txExpandedName.h"
+
+txOutputFormat::txOutputFormat()
+ : mMethod(eMethodNotSet),
+ mOmitXMLDeclaration(eNotSet),
+ mStandalone(eNotSet),
+ mIndent(eNotSet) {}
+
+txOutputFormat::~txOutputFormat() {
+ txListIterator iter(&mCDATASectionElements);
+ while (iter.hasNext()) delete (txExpandedName*)iter.next();
+}
+
+void txOutputFormat::reset() {
+ mMethod = eMethodNotSet;
+ mVersion.Truncate();
+ if (mEncoding.IsEmpty()) mOmitXMLDeclaration = eNotSet;
+ mStandalone = eNotSet;
+ mPublicId.Truncate();
+ mSystemId.Truncate();
+ txListIterator iter(&mCDATASectionElements);
+ while (iter.hasNext()) delete (txExpandedName*)iter.next();
+ mIndent = eNotSet;
+ mMediaType.Truncate();
+}
+
+void txOutputFormat::merge(txOutputFormat& aOutputFormat) {
+ if (mMethod == eMethodNotSet) mMethod = aOutputFormat.mMethod;
+
+ if (mVersion.IsEmpty()) mVersion = aOutputFormat.mVersion;
+
+ if (mEncoding.IsEmpty()) mEncoding = aOutputFormat.mEncoding;
+
+ if (mOmitXMLDeclaration == eNotSet)
+ mOmitXMLDeclaration = aOutputFormat.mOmitXMLDeclaration;
+
+ if (mStandalone == eNotSet) mStandalone = aOutputFormat.mStandalone;
+
+ if (mPublicId.IsEmpty()) mPublicId = aOutputFormat.mPublicId;
+
+ if (mSystemId.IsEmpty()) mSystemId = aOutputFormat.mSystemId;
+
+ txListIterator iter(&aOutputFormat.mCDATASectionElements);
+ txExpandedName* qName;
+ while ((qName = (txExpandedName*)iter.next())) {
+ mCDATASectionElements.add(qName);
+ // XXX We need txList.clear()
+ iter.remove();
+ }
+
+ if (mIndent == eNotSet) mIndent = aOutputFormat.mIndent;
+
+ if (mMediaType.IsEmpty()) mMediaType = aOutputFormat.mMediaType;
+}
+
+void txOutputFormat::setFromDefaults() {
+ switch (mMethod) {
+ case eMethodNotSet: {
+ mMethod = eXMLOutput;
+ [[fallthrough]];
+ }
+ case eXMLOutput: {
+ if (mVersion.IsEmpty()) mVersion.AppendLiteral("1.0");
+
+ if (mEncoding.IsEmpty()) mEncoding.AppendLiteral("UTF-8");
+
+ if (mOmitXMLDeclaration == eNotSet) mOmitXMLDeclaration = eFalse;
+
+ if (mIndent == eNotSet) mIndent = eFalse;
+
+ if (mMediaType.IsEmpty()) mMediaType.AppendLiteral("text/xml");
+
+ break;
+ }
+ case eHTMLOutput: {
+ if (mVersion.IsEmpty()) mVersion.AppendLiteral("4.0");
+
+ if (mEncoding.IsEmpty()) mEncoding.AppendLiteral("UTF-8");
+
+ if (mIndent == eNotSet) mIndent = eTrue;
+
+ if (mMediaType.IsEmpty()) mMediaType.AppendLiteral("text/html");
+
+ break;
+ }
+ case eTextOutput: {
+ if (mEncoding.IsEmpty()) mEncoding.AppendLiteral("UTF-8");
+
+ if (mMediaType.IsEmpty()) mMediaType.AppendLiteral("text/plain");
+
+ break;
+ }
+ }
+}
diff --git a/dom/xslt/xslt/txOutputFormat.h b/dom/xslt/xslt/txOutputFormat.h
new file mode 100644
index 0000000000..f511381d44
--- /dev/null
+++ b/dom/xslt/xslt/txOutputFormat.h
@@ -0,0 +1,64 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef TRANSFRMX_OUTPUTFORMAT_H
+#define TRANSFRMX_OUTPUTFORMAT_H
+
+#include "txList.h"
+#include "nsString.h"
+
+enum txOutputMethod { eMethodNotSet, eXMLOutput, eHTMLOutput, eTextOutput };
+
+enum txThreeState { eNotSet, eFalse, eTrue };
+
+class txOutputFormat {
+ public:
+ txOutputFormat();
+ ~txOutputFormat();
+
+ // "Unset" all values
+ void reset();
+
+ // Merges in the values of aOutputFormat, members that already
+ // have a value in this txOutputFormat will not be changed.
+ void merge(txOutputFormat& aOutputFormat);
+
+ // Sets members that have no value to their default value.
+ void setFromDefaults();
+
+ // The XSLT output method, which can be "xml", "html", or "text"
+ txOutputMethod mMethod;
+
+ // The xml version number that should be used when serializing
+ // xml documents
+ nsString mVersion;
+
+ // The XML character encoding that should be used when serializing
+ // xml documents
+ nsString mEncoding;
+
+ // Signals if we should output an XML declaration
+ txThreeState mOmitXMLDeclaration;
+
+ // Signals if we should output a standalone document declaration
+ txThreeState mStandalone;
+
+ // The public Id for creating a DOCTYPE
+ nsString mPublicId;
+
+ // The System Id for creating a DOCTYPE
+ nsString mSystemId;
+
+ // The elements whose text node children should be output as CDATA
+ txList mCDATASectionElements;
+
+ // Signals if output should be indented
+ txThreeState mIndent;
+
+ // The media type of the output
+ nsCString mMediaType;
+};
+
+#endif
diff --git a/dom/xslt/xslt/txPatternOptimizer.cpp b/dom/xslt/xslt/txPatternOptimizer.cpp
new file mode 100644
index 0000000000..4d0a68d188
--- /dev/null
+++ b/dom/xslt/xslt/txPatternOptimizer.cpp
@@ -0,0 +1,65 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txPatternOptimizer.h"
+#include "txXSLTPatterns.h"
+
+void txPatternOptimizer::optimize(txPattern* aInPattern,
+ txPattern** aOutPattern) {
+ *aOutPattern = nullptr;
+
+ // First optimize sub expressions
+ uint32_t i = 0;
+ Expr* subExpr;
+ while ((subExpr = aInPattern->getSubExprAt(i))) {
+ Expr* newExpr = nullptr;
+ mXPathOptimizer.optimize(subExpr, &newExpr);
+ if (newExpr) {
+ delete subExpr;
+ aInPattern->setSubExprAt(i, newExpr);
+ }
+
+ ++i;
+ }
+
+ // Then optimize sub patterns
+ txPattern* subPattern;
+ i = 0;
+ while ((subPattern = aInPattern->getSubPatternAt(i))) {
+ txPattern* newPattern = nullptr;
+ optimize(subPattern, &newPattern);
+ if (newPattern) {
+ delete subPattern;
+ aInPattern->setSubPatternAt(i, newPattern);
+ }
+
+ ++i;
+ }
+
+ // Finally see if current pattern can be optimized
+ switch (aInPattern->getType()) {
+ case txPattern::STEP_PATTERN:
+ optimizeStep(aInPattern, aOutPattern);
+ return;
+
+ default:
+ break;
+ }
+}
+
+void txPatternOptimizer::optimizeStep(txPattern* aInPattern,
+ txPattern** aOutPattern) {
+ txStepPattern* step = static_cast<txStepPattern*>(aInPattern);
+
+ // Test for predicates that can be combined into the nodetest
+ Expr* pred;
+ while ((pred = step->getSubExprAt(0)) &&
+ !pred->canReturnType(Expr::NUMBER_RESULT) &&
+ !pred->isSensitiveTo(Expr::NODESET_CONTEXT)) {
+ txNodeTest* predTest = new txPredicatedNodeTest(step->getNodeTest(), pred);
+ step->dropFirst();
+ step->setNodeTest(predTest);
+ }
+}
diff --git a/dom/xslt/xslt/txPatternOptimizer.h b/dom/xslt/xslt/txPatternOptimizer.h
new file mode 100644
index 0000000000..8ba3ffa625
--- /dev/null
+++ b/dom/xslt/xslt/txPatternOptimizer.h
@@ -0,0 +1,30 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef txPatternOptimizer_h__
+#define txPatternOptimizer_h__
+
+#include "txXPathOptimizer.h"
+
+class txPattern;
+
+class txPatternOptimizer {
+ public:
+ /**
+ * Optimize the given pattern.
+ * @param aInPattern Pattern to optimize.
+ * @param aOutPattern Resulting pattern, null if optimization didn't
+ * result in a new pattern.
+ */
+ void optimize(txPattern* aInPattern, txPattern** aOutPattern);
+
+ private:
+ // Helper methods for optimizing specific classes
+ void optimizeStep(txPattern* aInPattern, txPattern** aOutPattern);
+
+ txXPathOptimizer mXPathOptimizer;
+};
+
+#endif // txPatternOptimizer_h__
diff --git a/dom/xslt/xslt/txPatternParser.cpp b/dom/xslt/xslt/txPatternParser.cpp
new file mode 100644
index 0000000000..d012c8d549
--- /dev/null
+++ b/dom/xslt/xslt/txPatternParser.cpp
@@ -0,0 +1,260 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txPatternParser.h"
+#include "txExprLexer.h"
+#include "nsGkAtoms.h"
+#include "nsError.h"
+#include "txStringUtils.h"
+#include "txXSLTPatterns.h"
+#include "txStylesheetCompiler.h"
+#include "txPatternOptimizer.h"
+
+#include "mozilla/UniquePtrExtensions.h"
+
+using mozilla::UniquePtr;
+
+nsresult txPatternParser::createPattern(const nsString& aPattern,
+ txIParseContext* aContext,
+ txPattern** aResult) {
+ txExprLexer lexer;
+ nsresult rv = lexer.parse(aPattern);
+ if (NS_FAILED(rv)) {
+ // XXX error report parsing error
+ return rv;
+ }
+ UniquePtr<txPattern> pattern;
+ rv = createUnionPattern(lexer, aContext, *getter_Transfers(pattern));
+ if (NS_FAILED(rv)) {
+ // XXX error report parsing error
+ return rv;
+ }
+
+ txPatternOptimizer optimizer;
+ txPattern* newPattern = nullptr;
+ optimizer.optimize(pattern.get(), &newPattern);
+
+ *aResult = newPattern ? newPattern : pattern.release();
+
+ return NS_OK;
+}
+
+nsresult txPatternParser::createUnionPattern(txExprLexer& aLexer,
+ txIParseContext* aContext,
+ txPattern*& aPattern) {
+ nsresult rv = NS_OK;
+ txPattern* locPath = 0;
+
+ rv = createLocPathPattern(aLexer, aContext, locPath);
+ if (NS_FAILED(rv)) return rv;
+
+ Token::Type type = aLexer.peek()->mType;
+ if (type == Token::END) {
+ aPattern = locPath;
+ return NS_OK;
+ }
+
+ if (type != Token::UNION_OP) {
+ delete locPath;
+ return NS_ERROR_XPATH_PARSE_FAILURE;
+ }
+
+ txUnionPattern* unionPattern = new txUnionPattern();
+ unionPattern->addPattern(locPath);
+
+ aLexer.nextToken();
+ do {
+ rv = createLocPathPattern(aLexer, aContext, locPath);
+ if (NS_FAILED(rv)) {
+ delete unionPattern;
+ return rv;
+ }
+ unionPattern->addPattern(locPath);
+ type = aLexer.nextToken()->mType;
+ } while (type == Token::UNION_OP);
+
+ if (type != Token::END) {
+ delete unionPattern;
+ return NS_ERROR_XPATH_PARSE_FAILURE;
+ }
+
+ aPattern = unionPattern;
+ return NS_OK;
+}
+
+nsresult txPatternParser::createLocPathPattern(txExprLexer& aLexer,
+ txIParseContext* aContext,
+ txPattern*& aPattern) {
+ nsresult rv = NS_OK;
+
+ bool isChild = true;
+ bool isAbsolute = false;
+ txPattern* stepPattern = 0;
+ txLocPathPattern* pathPattern = 0;
+
+ Token::Type type = aLexer.peek()->mType;
+ switch (type) {
+ case Token::ANCESTOR_OP:
+ isChild = false;
+ isAbsolute = true;
+ aLexer.nextToken();
+ break;
+ case Token::PARENT_OP:
+ aLexer.nextToken();
+ isAbsolute = true;
+ if (aLexer.peek()->mType == Token::END ||
+ aLexer.peek()->mType == Token::UNION_OP) {
+ aPattern = new txRootPattern();
+ return NS_OK;
+ }
+ break;
+ case Token::FUNCTION_NAME_AND_PAREN:
+ // id(Literal) or key(Literal, Literal)
+ {
+ RefPtr<nsAtom> nameAtom = NS_Atomize(aLexer.nextToken()->Value());
+ if (nameAtom == nsGkAtoms::id) {
+ rv = createIdPattern(aLexer, stepPattern);
+ } else if (nameAtom == nsGkAtoms::key) {
+ rv = createKeyPattern(aLexer, aContext, stepPattern);
+ }
+ if (NS_FAILED(rv)) return rv;
+ }
+ break;
+ default:
+ break;
+ }
+ if (!stepPattern) {
+ rv = createStepPattern(aLexer, aContext, stepPattern);
+ if (NS_FAILED(rv)) return rv;
+ }
+
+ type = aLexer.peek()->mType;
+ if (!isAbsolute && type != Token::PARENT_OP && type != Token::ANCESTOR_OP) {
+ aPattern = stepPattern;
+ return NS_OK;
+ }
+
+ pathPattern = new txLocPathPattern();
+ if (isAbsolute) {
+ txRootPattern* root = new txRootPattern();
+#ifdef TX_TO_STRING
+ root->setSerialize(false);
+#endif
+
+ pathPattern->addStep(root, isChild);
+ }
+
+ pathPattern->addStep(stepPattern, isChild);
+ stepPattern = 0; // stepPattern is part of pathPattern now
+
+ while (type == Token::PARENT_OP || type == Token::ANCESTOR_OP) {
+ isChild = type == Token::PARENT_OP;
+ aLexer.nextToken();
+ rv = createStepPattern(aLexer, aContext, stepPattern);
+ if (NS_FAILED(rv)) {
+ delete pathPattern;
+ return rv;
+ }
+ pathPattern->addStep(stepPattern, isChild);
+ stepPattern = 0; // stepPattern is part of pathPattern now
+ type = aLexer.peek()->mType;
+ }
+ aPattern = pathPattern;
+ return rv;
+}
+
+nsresult txPatternParser::createIdPattern(txExprLexer& aLexer,
+ txPattern*& aPattern) {
+ // check for '(' Literal ')'
+ if (aLexer.peek()->mType != Token::LITERAL)
+ return NS_ERROR_XPATH_PARSE_FAILURE;
+ const nsDependentSubstring& value = aLexer.nextToken()->Value();
+ if (aLexer.nextToken()->mType != Token::R_PAREN)
+ return NS_ERROR_XPATH_PARSE_FAILURE;
+ aPattern = new txIdPattern(value);
+ return NS_OK;
+}
+
+nsresult txPatternParser::createKeyPattern(txExprLexer& aLexer,
+ txIParseContext* aContext,
+ txPattern*& aPattern) {
+ // check for '(' Literal, Literal ')'
+ if (aLexer.peek()->mType != Token::LITERAL)
+ return NS_ERROR_XPATH_PARSE_FAILURE;
+ const nsDependentSubstring& key = aLexer.nextToken()->Value();
+ if (aLexer.nextToken()->mType != Token::COMMA &&
+ aLexer.peek()->mType != Token::LITERAL)
+ return NS_ERROR_XPATH_PARSE_FAILURE;
+ const nsDependentSubstring& value = aLexer.nextToken()->Value();
+ if (aLexer.nextToken()->mType != Token::R_PAREN)
+ return NS_ERROR_XPATH_PARSE_FAILURE;
+
+ if (!aContext->allowed(txIParseContext::KEY_FUNCTION))
+ return NS_ERROR_XSLT_CALL_TO_KEY_NOT_ALLOWED;
+
+ const char16_t* colon;
+ if (!XMLUtils::isValidQName(key, &colon)) {
+ return NS_ERROR_XPATH_PARSE_FAILURE;
+ }
+ RefPtr<nsAtom> prefix, localName;
+ int32_t namespaceID;
+ nsresult rv = resolveQName(key, getter_AddRefs(prefix), aContext,
+ getter_AddRefs(localName), namespaceID);
+ if (NS_FAILED(rv)) return rv;
+
+ aPattern = new txKeyPattern(prefix, localName, namespaceID, value);
+ return NS_OK;
+}
+
+nsresult txPatternParser::createStepPattern(txExprLexer& aLexer,
+ txIParseContext* aContext,
+ txPattern*& aPattern) {
+ nsresult rv = NS_OK;
+ bool isAttr = false;
+ Token* tok = aLexer.peek();
+ if (tok->mType == Token::AXIS_IDENTIFIER) {
+ if (TX_StringEqualsAtom(tok->Value(), nsGkAtoms::attribute)) {
+ isAttr = true;
+ } else if (!TX_StringEqualsAtom(tok->Value(), nsGkAtoms::child)) {
+ // all done already for CHILD_AXIS, for all others
+ // XXX report unexpected axis error
+ return NS_ERROR_XPATH_PARSE_FAILURE;
+ }
+ aLexer.nextToken();
+ } else if (tok->mType == Token::AT_SIGN) {
+ aLexer.nextToken();
+ isAttr = true;
+ }
+
+ txNodeTest* nodeTest;
+ if (aLexer.peek()->mType == Token::CNAME) {
+ tok = aLexer.nextToken();
+
+ // resolve QName
+ RefPtr<nsAtom> prefix, lName;
+ int32_t nspace;
+ rv = resolveQName(tok->Value(), getter_AddRefs(prefix), aContext,
+ getter_AddRefs(lName), nspace, true);
+ if (NS_FAILED(rv)) {
+ // XXX error report namespace resolve failed
+ return rv;
+ }
+
+ uint16_t nodeType = isAttr ? (uint16_t)txXPathNodeType::ATTRIBUTE_NODE
+ : (uint16_t)txXPathNodeType::ELEMENT_NODE;
+ nodeTest = new txNameTest(prefix, lName, nspace, nodeType);
+ } else {
+ rv = createNodeTypeTest(aLexer, &nodeTest);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ UniquePtr<txStepPattern> step(new txStepPattern(nodeTest, isAttr));
+ rv = parsePredicates(step.get(), aLexer, aContext);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aPattern = step.release();
+
+ return NS_OK;
+}
diff --git a/dom/xslt/xslt/txPatternParser.h b/dom/xslt/xslt/txPatternParser.h
new file mode 100644
index 0000000000..fcb9a1da0e
--- /dev/null
+++ b/dom/xslt/xslt/txPatternParser.h
@@ -0,0 +1,35 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef TX_PATTERNPARSER_H
+#define TX_PATTERNPARSER_H
+
+#include "txXSLTPatterns.h"
+#include "txExprParser.h"
+
+class txStylesheetCompilerState;
+
+class txPatternParser : public txExprParser {
+ public:
+ static nsresult createPattern(const nsString& aPattern,
+ txIParseContext* aContext, txPattern** aResult);
+
+ protected:
+ static nsresult createUnionPattern(txExprLexer& aLexer,
+ txIParseContext* aContext,
+ txPattern*& aPattern);
+ static nsresult createLocPathPattern(txExprLexer& aLexer,
+ txIParseContext* aContext,
+ txPattern*& aPattern);
+ static nsresult createIdPattern(txExprLexer& aLexer, txPattern*& aPattern);
+ static nsresult createKeyPattern(txExprLexer& aLexer,
+ txIParseContext* aContext,
+ txPattern*& aPattern);
+ static nsresult createStepPattern(txExprLexer& aLexer,
+ txIParseContext* aContext,
+ txPattern*& aPattern);
+};
+
+#endif // TX_PATTERNPARSER_H
diff --git a/dom/xslt/xslt/txRtfHandler.cpp b/dom/xslt/xslt/txRtfHandler.cpp
new file mode 100644
index 0000000000..eaa40d8637
--- /dev/null
+++ b/dom/xslt/xslt/txRtfHandler.cpp
@@ -0,0 +1,54 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txRtfHandler.h"
+
+#include <utility>
+
+txResultTreeFragment::txResultTreeFragment(
+ mozilla::UniquePtr<txResultBuffer>&& aBuffer)
+ : txAExprResult(nullptr), mBuffer(std::move(aBuffer)) {}
+
+short txResultTreeFragment::getResultType() { return RESULT_TREE_FRAGMENT; }
+
+void txResultTreeFragment::stringValue(nsString& aResult) {
+ if (!mBuffer) {
+ return;
+ }
+
+ aResult.Append(mBuffer->mStringValue);
+}
+
+const nsString* txResultTreeFragment::stringValuePointer() {
+ return mBuffer ? &mBuffer->mStringValue : nullptr;
+}
+
+bool txResultTreeFragment::booleanValue() { return true; }
+
+double txResultTreeFragment::numberValue() {
+ if (!mBuffer) {
+ return 0;
+ }
+
+ return txDouble::toDouble(mBuffer->mStringValue);
+}
+
+nsresult txResultTreeFragment::flushToHandler(txAXMLEventHandler* aHandler) {
+ if (!mBuffer) {
+ return NS_ERROR_FAILURE;
+ }
+
+ return mBuffer->flushToHandler(aHandler);
+}
+
+nsresult txRtfHandler::getAsRTF(txAExprResult** aResult) {
+ *aResult = new txResultTreeFragment(std::move(mBuffer));
+ NS_ADDREF(*aResult);
+ return NS_OK;
+}
+
+nsresult txRtfHandler::endDocument(nsresult aResult) { return NS_OK; }
+
+nsresult txRtfHandler::startDocument() { return NS_OK; }
diff --git a/dom/xslt/xslt/txRtfHandler.h b/dom/xslt/xslt/txRtfHandler.h
new file mode 100644
index 0000000000..ee0debf1a0
--- /dev/null
+++ b/dom/xslt/xslt/txRtfHandler.h
@@ -0,0 +1,42 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef txRtfHandler_h___
+#define txRtfHandler_h___
+
+#include "mozilla/Attributes.h"
+#include "txBufferingHandler.h"
+#include "txExprResult.h"
+#include "txXPathNode.h"
+
+class txResultTreeFragment : public txAExprResult {
+ public:
+ explicit txResultTreeFragment(mozilla::UniquePtr<txResultBuffer>&& aBuffer);
+
+ TX_DECL_EXPRRESULT
+
+ nsresult flushToHandler(txAXMLEventHandler* aHandler);
+
+ void setNode(const txXPathNode* aNode) {
+ NS_ASSERTION(!mNode, "Already converted!");
+
+ mNode = mozilla::WrapUnique(aNode);
+ }
+ const txXPathNode* getNode() const { return mNode.get(); }
+
+ private:
+ mozilla::UniquePtr<txResultBuffer> mBuffer;
+ mozilla::UniquePtr<const txXPathNode> mNode;
+};
+
+class txRtfHandler : public txBufferingHandler {
+ public:
+ nsresult getAsRTF(txAExprResult** aResult);
+
+ nsresult endDocument(nsresult aResult) override;
+ nsresult startDocument() override;
+};
+
+#endif /* txRtfHandler_h___ */
diff --git a/dom/xslt/xslt/txStylesheet.cpp b/dom/xslt/xslt/txStylesheet.cpp
new file mode 100644
index 0000000000..5226ef5e08
--- /dev/null
+++ b/dom/xslt/xslt/txStylesheet.cpp
@@ -0,0 +1,550 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txStylesheet.h"
+
+#include <utility>
+
+#include "mozilla/FloatingPoint.h"
+#include "txExpr.h"
+#include "txInstructions.h"
+#include "txKey.h"
+#include "txLog.h"
+#include "txToplevelItems.h"
+#include "txXPathTreeWalker.h"
+#include "txXSLTFunctions.h"
+#include "txXSLTPatterns.h"
+
+using mozilla::LogLevel;
+using mozilla::MakeUnique;
+using mozilla::UniquePtr;
+using mozilla::Unused;
+using mozilla::WrapUnique;
+
+txStylesheet::txStylesheet() : mRootFrame(nullptr) {}
+
+nsresult txStylesheet::init() {
+ mRootFrame = new ImportFrame;
+
+ // Create default templates
+ // element/root template
+ mContainerTemplate = MakeUnique<txPushParams>();
+
+ UniquePtr<txNodeTest> nt(new txNodeTypeTest(txNodeTypeTest::NODE_TYPE));
+ UniquePtr<Expr> nodeExpr(
+ new LocationStep(nt.get(), LocationStep::CHILD_AXIS));
+ Unused << nt.release();
+
+ txPushNewContext* pushContext = new txPushNewContext(std::move(nodeExpr));
+ mContainerTemplate->mNext = WrapUnique(pushContext);
+
+ txApplyDefaultElementTemplate* applyTemplates =
+ new txApplyDefaultElementTemplate;
+ pushContext->mNext = WrapUnique(applyTemplates);
+
+ txLoopNodeSet* loopNodeSet = new txLoopNodeSet(applyTemplates);
+ applyTemplates->mNext = WrapUnique(loopNodeSet);
+
+ txPopParams* popParams = new txPopParams;
+ loopNodeSet->mNext = WrapUnique(popParams);
+ pushContext->mBailTarget = loopNodeSet->mNext.get();
+
+ popParams->mNext = MakeUnique<txReturn>();
+
+ // attribute/textnode template
+ nt = MakeUnique<txNodeTypeTest>(txNodeTypeTest::NODE_TYPE);
+ nodeExpr = MakeUnique<LocationStep>(nt.get(), LocationStep::SELF_AXIS);
+ Unused << nt.release();
+
+ mCharactersTemplate = MakeUnique<txValueOf>(std::move(nodeExpr), false);
+ mCharactersTemplate->mNext = MakeUnique<txReturn>();
+
+ // pi/comment/namespace template
+ mEmptyTemplate = MakeUnique<txReturn>();
+
+ return NS_OK;
+}
+
+txStylesheet::~txStylesheet() {
+ // Delete all ImportFrames
+ delete mRootFrame;
+ txListIterator frameIter(&mImportFrames);
+ while (frameIter.hasNext()) {
+ delete static_cast<ImportFrame*>(frameIter.next());
+ }
+
+ txListIterator instrIter(&mTemplateInstructions);
+ while (instrIter.hasNext()) {
+ delete static_cast<txInstruction*>(instrIter.next());
+ }
+
+ // We can't make the map own its values because then we wouldn't be able
+ // to merge attributesets of the same name
+ txExpandedNameMap<txInstruction>::iterator attrSetIter(mAttributeSets);
+ while (attrSetIter.next()) {
+ delete attrSetIter.value();
+ }
+}
+
+nsresult txStylesheet::findTemplate(const txXPathNode& aNode,
+ const txExpandedName& aMode,
+ txIMatchContext* aContext,
+ ImportFrame* aImportedBy,
+ txInstruction** aTemplate,
+ ImportFrame** aImportFrame) {
+ NS_ASSERTION(aImportFrame, "missing ImportFrame pointer");
+
+ *aTemplate = nullptr;
+ *aImportFrame = nullptr;
+ ImportFrame* endFrame = nullptr;
+ txListIterator frameIter(&mImportFrames);
+
+ if (aImportedBy) {
+ ImportFrame* curr = static_cast<ImportFrame*>(frameIter.next());
+ while (curr != aImportedBy) {
+ curr = static_cast<ImportFrame*>(frameIter.next());
+ }
+ endFrame = aImportedBy->mFirstNotImported;
+ }
+
+#if defined(TX_TO_STRING)
+ txPattern* match = 0;
+#endif
+
+ ImportFrame* frame;
+ while (!*aTemplate && (frame = static_cast<ImportFrame*>(frameIter.next())) &&
+ frame != endFrame) {
+ // get templatelist for this mode
+ nsTArray<MatchableTemplate>* templates =
+ frame->mMatchableTemplates.get(aMode);
+
+ if (templates) {
+ // Find template with highest priority
+ uint32_t i, len = templates->Length();
+ for (i = 0; i < len && !*aTemplate; ++i) {
+ MatchableTemplate& templ = (*templates)[i];
+ bool matched;
+ nsresult rv = templ.mMatch->matches(aNode, aContext, matched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (matched) {
+ *aTemplate = templ.mFirstInstruction;
+ *aImportFrame = frame;
+#if defined(TX_TO_STRING)
+ match = templ.mMatch.get();
+#endif
+ }
+ }
+ }
+ }
+
+ if (MOZ_LOG_TEST(txLog::xslt, LogLevel::Debug)) {
+ nsAutoString mode, nodeName;
+ if (aMode.mLocalName) {
+ aMode.mLocalName->ToString(mode);
+ }
+ txXPathNodeUtils::getNodeName(aNode, nodeName);
+ if (*aTemplate) {
+ nsAutoString matchAttr;
+#ifdef TX_TO_STRING
+ match->toString(matchAttr);
+#endif
+ MOZ_LOG(txLog::xslt, LogLevel::Debug,
+ ("MatchTemplate, Pattern %s, Mode %s, Node %s\n",
+ NS_LossyConvertUTF16toASCII(matchAttr).get(),
+ NS_LossyConvertUTF16toASCII(mode).get(),
+ NS_LossyConvertUTF16toASCII(nodeName).get()));
+ } else {
+ MOZ_LOG(txLog::xslt, LogLevel::Debug,
+ ("No match, Node %s, Mode %s\n",
+ NS_LossyConvertUTF16toASCII(nodeName).get(),
+ NS_LossyConvertUTF16toASCII(mode).get()));
+ }
+ }
+
+ if (!*aTemplate) {
+ // Test for these first since a node can be both a text node
+ // and a root (if it is orphaned)
+ if (txXPathNodeUtils::isAttribute(aNode) ||
+ txXPathNodeUtils::isText(aNode)) {
+ *aTemplate = mCharactersTemplate.get();
+ } else if (txXPathNodeUtils::isElement(aNode) ||
+ txXPathNodeUtils::isRoot(aNode)) {
+ *aTemplate = mContainerTemplate.get();
+ } else {
+ *aTemplate = mEmptyTemplate.get();
+ }
+ }
+
+ return NS_OK;
+}
+
+txDecimalFormat* txStylesheet::getDecimalFormat(const txExpandedName& aName) {
+ return mDecimalFormats.get(aName);
+}
+
+txInstruction* txStylesheet::getAttributeSet(const txExpandedName& aName) {
+ return mAttributeSets.get(aName);
+}
+
+txInstruction* txStylesheet::getNamedTemplate(const txExpandedName& aName) {
+ return mNamedTemplates.get(aName);
+}
+
+txOutputFormat* txStylesheet::getOutputFormat() { return &mOutputFormat; }
+
+txStylesheet::GlobalVariable* txStylesheet::getGlobalVariable(
+ const txExpandedName& aName) {
+ return mGlobalVariables.get(aName);
+}
+
+const txOwningExpandedNameMap<txXSLKey>& txStylesheet::getKeyMap() {
+ return mKeys;
+}
+
+nsresult txStylesheet::isStripSpaceAllowed(const txXPathNode& aNode,
+ txIMatchContext* aContext,
+ bool& aAllowed) {
+ int32_t frameCount = mStripSpaceTests.Length();
+ if (frameCount == 0) {
+ aAllowed = false;
+
+ return NS_OK;
+ }
+
+ txXPathTreeWalker walker(aNode);
+
+ if (txXPathNodeUtils::isText(walker.getCurrentPosition()) &&
+ (!txXPathNodeUtils::isWhitespace(aNode) || !walker.moveToParent())) {
+ aAllowed = false;
+
+ return NS_OK;
+ }
+
+ const txXPathNode& node = walker.getCurrentPosition();
+
+ if (!txXPathNodeUtils::isElement(node)) {
+ aAllowed = false;
+
+ return NS_OK;
+ }
+
+ // check Whitespace stipping handling list against given Node
+ int32_t i;
+ for (i = 0; i < frameCount; ++i) {
+ const auto& sst = mStripSpaceTests[i];
+ bool matched;
+ nsresult rv = sst->matches(node, aContext, matched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (matched) {
+ aAllowed = sst->stripsSpace() && !XMLUtils::getXMLSpacePreserve(node);
+
+ return NS_OK;
+ }
+ }
+
+ aAllowed = false;
+
+ return NS_OK;
+}
+
+nsresult txStylesheet::doneCompiling() {
+ nsresult rv = NS_OK;
+ // Collect all importframes into a single ordered list
+ txListIterator frameIter(&mImportFrames);
+ frameIter.addAfter(mRootFrame);
+
+ mRootFrame = nullptr;
+ frameIter.next();
+ rv = addFrames(frameIter);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // Loop through importframes in decreasing-precedence-order and process
+ // all items
+ frameIter.reset();
+ ImportFrame* frame;
+ while ((frame = static_cast<ImportFrame*>(frameIter.next()))) {
+ nsTArray<txStripSpaceTest*> frameStripSpaceTests;
+
+ txListIterator itemIter(&frame->mToplevelItems);
+ itemIter.resetToEnd();
+ txToplevelItem* item;
+ while ((item = static_cast<txToplevelItem*>(itemIter.previous()))) {
+ switch (item->getType()) {
+ case txToplevelItem::attributeSet: {
+ rv = addAttributeSet(static_cast<txAttributeSetItem*>(item));
+ NS_ENSURE_SUCCESS(rv, rv);
+ break;
+ }
+ case txToplevelItem::dummy:
+ case txToplevelItem::import: {
+ break;
+ }
+ case txToplevelItem::output: {
+ mOutputFormat.merge(static_cast<txOutputItem*>(item)->mFormat);
+ break;
+ }
+ case txToplevelItem::stripSpace: {
+ rv = addStripSpace(static_cast<txStripSpaceItem*>(item),
+ frameStripSpaceTests);
+ NS_ENSURE_SUCCESS(rv, rv);
+ break;
+ }
+ case txToplevelItem::templ: {
+ rv = addTemplate(static_cast<txTemplateItem*>(item), frame);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ break;
+ }
+ case txToplevelItem::variable: {
+ rv = addGlobalVariable(static_cast<txVariableItem*>(item));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ break;
+ }
+ }
+ delete item;
+ itemIter.remove(); // remove() moves to the previous
+ itemIter.next();
+ }
+ mStripSpaceTests.AppendElements(frameStripSpaceTests);
+ frameStripSpaceTests.Clear();
+ }
+
+ if (!mDecimalFormats.get(txExpandedName())) {
+ UniquePtr<txDecimalFormat> format(new txDecimalFormat);
+ rv = mDecimalFormats.add(txExpandedName(), format.get());
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ Unused << format.release();
+ }
+
+ return NS_OK;
+}
+
+nsresult txStylesheet::addTemplate(txTemplateItem* aTemplate,
+ ImportFrame* aImportFrame) {
+ NS_ASSERTION(aTemplate, "missing template");
+
+ txInstruction* instr = aTemplate->mFirstInstruction.get();
+ mTemplateInstructions.add(instr);
+
+ // mTemplateInstructions now owns the instructions
+ Unused << aTemplate->mFirstInstruction.release();
+
+ if (!aTemplate->mName.isNull()) {
+ nsresult rv = mNamedTemplates.add(aTemplate->mName, instr);
+ NS_ENSURE_TRUE(NS_SUCCEEDED(rv) || rv == NS_ERROR_XSLT_ALREADY_SET, rv);
+ }
+
+ if (!aTemplate->mMatch) {
+ // This is no error, see section 6 Named Templates
+
+ return NS_OK;
+ }
+
+ // get the txList for the right mode
+ nsTArray<MatchableTemplate>* templates =
+ aImportFrame->mMatchableTemplates.get(aTemplate->mMode);
+
+ if (!templates) {
+ UniquePtr<nsTArray<MatchableTemplate>> newList(
+ new nsTArray<MatchableTemplate>);
+ nsresult rv =
+ aImportFrame->mMatchableTemplates.set(aTemplate->mMode, newList.get());
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ templates = newList.release();
+ }
+
+ // Add the simple patterns to the list of matchable templates, according
+ // to default priority
+ UniquePtr<txPattern> simple = std::move(aTemplate->mMatch);
+ UniquePtr<txPattern> unionPattern;
+ if (simple->getType() == txPattern::UNION_PATTERN) {
+ unionPattern = std::move(simple);
+ simple = WrapUnique(unionPattern->getSubPatternAt(0));
+ unionPattern->setSubPatternAt(0, nullptr);
+ }
+
+ uint32_t unionPos = 1; // only used when unionPattern is set
+ while (simple) {
+ double priority = aTemplate->mPrio;
+ if (std::isnan(priority)) {
+ priority = simple->getDefaultPriority();
+ NS_ASSERTION(!std::isnan(priority),
+ "simple pattern without default priority");
+ }
+
+ uint32_t i, len = templates->Length();
+ for (i = 0; i < len; ++i) {
+ if (priority > (*templates)[i].mPriority) {
+ break;
+ }
+ }
+
+ MatchableTemplate* nt = templates->InsertElementAt(i);
+ nt->mFirstInstruction = instr;
+ nt->mMatch = std::move(simple);
+ nt->mPriority = priority;
+
+ if (unionPattern) {
+ simple = WrapUnique(unionPattern->getSubPatternAt(unionPos));
+ if (simple) {
+ unionPattern->setSubPatternAt(unionPos, nullptr);
+ }
+ ++unionPos;
+ }
+ }
+
+ return NS_OK;
+}
+
+nsresult txStylesheet::addFrames(txListIterator& aInsertIter) {
+ ImportFrame* frame = static_cast<ImportFrame*>(aInsertIter.current());
+ nsresult rv = NS_OK;
+ txListIterator iter(&frame->mToplevelItems);
+ txToplevelItem* item;
+ while ((item = static_cast<txToplevelItem*>(iter.next()))) {
+ if (item->getType() == txToplevelItem::import) {
+ txImportItem* import = static_cast<txImportItem*>(item);
+ import->mFrame->mFirstNotImported =
+ static_cast<ImportFrame*>(aInsertIter.next());
+ aInsertIter.addBefore(import->mFrame.release());
+ aInsertIter.previous();
+ rv = addFrames(aInsertIter);
+ NS_ENSURE_SUCCESS(rv, rv);
+ aInsertIter.previous();
+ }
+ }
+
+ return NS_OK;
+}
+
+nsresult txStylesheet::addStripSpace(
+ txStripSpaceItem* aStripSpaceItem,
+ nsTArray<txStripSpaceTest*>& aFrameStripSpaceTests) {
+ int32_t testCount = aStripSpaceItem->mStripSpaceTests.Length();
+ for (; testCount > 0; --testCount) {
+ txStripSpaceTest* sst = aStripSpaceItem->mStripSpaceTests[testCount - 1];
+ double priority = sst->getDefaultPriority();
+ int32_t i, frameCount = aFrameStripSpaceTests.Length();
+ for (i = 0; i < frameCount; ++i) {
+ if (aFrameStripSpaceTests[i]->getDefaultPriority() < priority) {
+ break;
+ }
+ }
+ aFrameStripSpaceTests.InsertElementAt(i, sst);
+ aStripSpaceItem->mStripSpaceTests.RemoveElementAt(testCount - 1);
+ }
+
+ return NS_OK;
+}
+
+nsresult txStylesheet::addAttributeSet(txAttributeSetItem* aAttributeSetItem) {
+ nsresult rv = NS_OK;
+ txInstruction* oldInstr = mAttributeSets.get(aAttributeSetItem->mName);
+ if (!oldInstr) {
+ rv = mAttributeSets.add(aAttributeSetItem->mName,
+ aAttributeSetItem->mFirstInstruction.get());
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ Unused << aAttributeSetItem->mFirstInstruction.release();
+
+ return NS_OK;
+ }
+
+ // We need to prepend the new instructions before the existing ones.
+ txInstruction* instr = aAttributeSetItem->mFirstInstruction.get();
+ txInstruction* lastNonReturn = nullptr;
+ while (instr->mNext) {
+ lastNonReturn = instr;
+ instr = instr->mNext.get();
+ }
+
+ if (!lastNonReturn) {
+ // The new attributeset is empty, so lets just ignore it.
+ return NS_OK;
+ }
+
+ rv = mAttributeSets.set(aAttributeSetItem->mName,
+ aAttributeSetItem->mFirstInstruction.get());
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ Unused << aAttributeSetItem->mFirstInstruction.release();
+
+ lastNonReturn->mNext =
+ WrapUnique(oldInstr); // ...and link up the old instructions.
+
+ return NS_OK;
+}
+
+nsresult txStylesheet::addGlobalVariable(txVariableItem* aVariable) {
+ if (mGlobalVariables.get(aVariable->mName)) {
+ return NS_OK;
+ }
+ UniquePtr<GlobalVariable> var(new GlobalVariable(
+ std::move(aVariable->mValue), std::move(aVariable->mFirstInstruction),
+ aVariable->mIsParam));
+ nsresult rv = mGlobalVariables.add(aVariable->mName, var.get());
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ Unused << var.release();
+
+ return NS_OK;
+}
+
+nsresult txStylesheet::addKey(const txExpandedName& aName,
+ UniquePtr<txPattern> aMatch,
+ UniquePtr<Expr> aUse) {
+ nsresult rv = NS_OK;
+
+ txXSLKey* xslKey = mKeys.get(aName);
+ if (!xslKey) {
+ xslKey = new txXSLKey(aName);
+ rv = mKeys.add(aName, xslKey);
+ if (NS_FAILED(rv)) {
+ delete xslKey;
+ return rv;
+ }
+ }
+ if (!xslKey->addKey(std::move(aMatch), std::move(aUse))) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+ return NS_OK;
+}
+
+nsresult txStylesheet::addDecimalFormat(const txExpandedName& aName,
+ UniquePtr<txDecimalFormat>&& aFormat) {
+ txDecimalFormat* existing = mDecimalFormats.get(aName);
+ if (existing) {
+ NS_ENSURE_TRUE(existing->isEqual(aFormat.get()),
+ NS_ERROR_XSLT_PARSE_FAILURE);
+
+ return NS_OK;
+ }
+
+ nsresult rv = mDecimalFormats.add(aName, aFormat.get());
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ Unused << aFormat.release();
+
+ return NS_OK;
+}
+
+txStylesheet::ImportFrame::~ImportFrame() {
+ txListIterator tlIter(&mToplevelItems);
+ while (tlIter.hasNext()) {
+ delete static_cast<txToplevelItem*>(tlIter.next());
+ }
+}
+
+txStylesheet::GlobalVariable::GlobalVariable(UniquePtr<Expr>&& aExpr,
+ UniquePtr<txInstruction>&& aInstr,
+ bool aIsParam)
+ : mExpr(std::move(aExpr)),
+ mFirstInstruction(std::move(aInstr)),
+ mIsParam(aIsParam) {}
diff --git a/dom/xslt/xslt/txStylesheet.h b/dom/xslt/xslt/txStylesheet.h
new file mode 100644
index 0000000000..f37b8acdbc
--- /dev/null
+++ b/dom/xslt/xslt/txStylesheet.h
@@ -0,0 +1,185 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef TX_TXSTYLESHEET_H
+#define TX_TXSTYLESHEET_H
+
+#include "txOutputFormat.h"
+#include "txExpandedNameMap.h"
+#include "txList.h"
+#include "txXSLTPatterns.h"
+#include "nsISupportsImpl.h"
+
+class txInstruction;
+class txTemplateItem;
+class txVariableItem;
+class txStripSpaceItem;
+class txAttributeSetItem;
+class txDecimalFormat;
+class txStripSpaceTest;
+class txXSLKey;
+
+class txStylesheet final {
+ public:
+ class ImportFrame;
+ class GlobalVariable;
+ friend class txStylesheetCompilerState;
+ // To be able to do some cleaning up in destructor
+ friend class ImportFrame;
+
+ txStylesheet();
+ nsresult init();
+
+ NS_INLINE_DECL_REFCOUNTING(txStylesheet)
+
+ nsresult findTemplate(const txXPathNode& aNode, const txExpandedName& aMode,
+ txIMatchContext* aContext, ImportFrame* aImportedBy,
+ txInstruction** aTemplate, ImportFrame** aImportFrame);
+ txDecimalFormat* getDecimalFormat(const txExpandedName& aName);
+ txInstruction* getAttributeSet(const txExpandedName& aName);
+ txInstruction* getNamedTemplate(const txExpandedName& aName);
+ txOutputFormat* getOutputFormat();
+ GlobalVariable* getGlobalVariable(const txExpandedName& aName);
+ const txOwningExpandedNameMap<txXSLKey>& getKeyMap();
+ nsresult isStripSpaceAllowed(const txXPathNode& aNode,
+ txIMatchContext* aContext, bool& aAllowed);
+
+ /**
+ * Called by the stylesheet compiler once all stylesheets has been read.
+ */
+ nsresult doneCompiling();
+
+ /**
+ * Add a key to the stylesheet
+ */
+ nsresult addKey(const txExpandedName& aName,
+ mozilla::UniquePtr<txPattern> aMatch,
+ mozilla::UniquePtr<Expr> aUse);
+
+ /**
+ * Add a decimal-format to the stylesheet
+ */
+ nsresult addDecimalFormat(const txExpandedName& aName,
+ mozilla::UniquePtr<txDecimalFormat>&& aFormat);
+
+ struct MatchableTemplate {
+ txInstruction* mFirstInstruction;
+ mozilla::UniquePtr<txPattern> mMatch;
+ double mPriority;
+ };
+
+ /**
+ * Contain information that is import precedence dependant.
+ */
+ class ImportFrame {
+ public:
+ ImportFrame() : mFirstNotImported(nullptr) {}
+ ~ImportFrame();
+
+ // List of toplevel items
+ txList mToplevelItems;
+
+ // Map of template modes
+ txOwningExpandedNameMap<nsTArray<MatchableTemplate> > mMatchableTemplates;
+
+ // ImportFrame which is the first one *not* imported by this frame
+ ImportFrame* mFirstNotImported;
+ };
+
+ class GlobalVariable : public txObject {
+ public:
+ GlobalVariable(mozilla::UniquePtr<Expr>&& aExpr,
+ mozilla::UniquePtr<txInstruction>&& aFirstInstruction,
+ bool aIsParam);
+
+ mozilla::UniquePtr<Expr> mExpr;
+ mozilla::UniquePtr<txInstruction> mFirstInstruction;
+ bool mIsParam;
+ };
+
+ private:
+ // Private destructor, to discourage deletion outside of Release():
+ ~txStylesheet();
+
+ nsresult addTemplate(txTemplateItem* aTemplate, ImportFrame* aImportFrame);
+ nsresult addGlobalVariable(txVariableItem* aVariable);
+ nsresult addFrames(txListIterator& aInsertIter);
+ nsresult addStripSpace(txStripSpaceItem* aStripSpaceItem,
+ nsTArray<txStripSpaceTest*>& aFrameStripSpaceTests);
+ nsresult addAttributeSet(txAttributeSetItem* aAttributeSetItem);
+
+ // List of ImportFrames
+ txList mImportFrames;
+
+ // output format
+ txOutputFormat mOutputFormat;
+
+ // List of first instructions of templates. This is the owner of all
+ // instructions used in templates
+ txList mTemplateInstructions;
+
+ // Root importframe
+ ImportFrame* mRootFrame;
+
+ // Named templates
+ txExpandedNameMap<txInstruction> mNamedTemplates;
+
+ // Map with all decimal-formats
+ txOwningExpandedNameMap<txDecimalFormat> mDecimalFormats;
+
+ // Map with all named attribute sets
+ txExpandedNameMap<txInstruction> mAttributeSets;
+
+ // Map with all global variables and parameters
+ txOwningExpandedNameMap<GlobalVariable> mGlobalVariables;
+
+ // Map with all keys
+ txOwningExpandedNameMap<txXSLKey> mKeys;
+
+ // Array of all txStripSpaceTests, sorted in acending order
+ nsTArray<mozilla::UniquePtr<txStripSpaceTest> > mStripSpaceTests;
+
+ // Default templates
+ mozilla::UniquePtr<txInstruction> mContainerTemplate;
+ mozilla::UniquePtr<txInstruction> mCharactersTemplate;
+ mozilla::UniquePtr<txInstruction> mEmptyTemplate;
+};
+
+/**
+ * txStripSpaceTest holds both an txNameTest and a bool for use in
+ * whitespace stripping.
+ */
+class txStripSpaceTest {
+ public:
+ txStripSpaceTest(nsAtom* aPrefix, nsAtom* aLocalName, int32_t aNSID,
+ bool stripSpace)
+ : mNameTest(aPrefix, aLocalName, aNSID, txXPathNodeType::ELEMENT_NODE),
+ mStrips(stripSpace) {}
+
+ nsresult matches(const txXPathNode& aNode, txIMatchContext* aContext,
+ bool& aMatched) {
+ return mNameTest.matches(aNode, aContext, aMatched);
+ }
+
+ bool stripsSpace() { return mStrips; }
+
+ double getDefaultPriority() { return mNameTest.getDefaultPriority(); }
+
+ protected:
+ txNameTest mNameTest;
+ bool mStrips;
+};
+
+/**
+ * Value of a global parameter
+ */
+class txIGlobalParameter {
+ public:
+ MOZ_COUNTED_DEFAULT_CTOR(txIGlobalParameter)
+ MOZ_COUNTED_DTOR_VIRTUAL(txIGlobalParameter)
+ virtual nsresult getValue(txAExprResult** aValue) = 0;
+};
+
+#endif // TX_TXSTYLESHEET_H
diff --git a/dom/xslt/xslt/txStylesheetCompileHandlers.cpp b/dom/xslt/xslt/txStylesheetCompileHandlers.cpp
new file mode 100644
index 0000000000..ddc9f6fb38
--- /dev/null
+++ b/dom/xslt/xslt/txStylesheetCompileHandlers.cpp
@@ -0,0 +1,2352 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txStylesheetCompileHandlers.h"
+
+#include <utility>
+
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/FloatingPoint.h"
+#include "mozilla/UniquePtrExtensions.h"
+#include "nsGkAtoms.h"
+#include "nsWhitespaceTokenizer.h"
+#include "txCore.h"
+#include "txInstructions.h"
+#include "txNamespaceMap.h"
+#include "txPatternParser.h"
+#include "txStringUtils.h"
+#include "txStylesheet.h"
+#include "txStylesheetCompiler.h"
+#include "txToplevelItems.h"
+#include "txURIUtils.h"
+#include "txXSLTFunctions.h"
+#include "nsStringFlags.h"
+#include "nsStyleUtil.h"
+#include "nsStringIterator.h"
+
+using namespace mozilla;
+
+txHandlerTable* gTxIgnoreHandler = 0;
+txHandlerTable* gTxRootHandler = 0;
+txHandlerTable* gTxEmbedHandler = 0;
+txHandlerTable* gTxTopHandler = 0;
+txHandlerTable* gTxTemplateHandler = 0;
+txHandlerTable* gTxTextHandler = 0;
+txHandlerTable* gTxApplyTemplatesHandler = 0;
+txHandlerTable* gTxCallTemplateHandler = 0;
+txHandlerTable* gTxVariableHandler = 0;
+txHandlerTable* gTxForEachHandler = 0;
+txHandlerTable* gTxTopVariableHandler = 0;
+txHandlerTable* gTxChooseHandler = 0;
+txHandlerTable* gTxParamHandler = 0;
+txHandlerTable* gTxImportHandler = 0;
+txHandlerTable* gTxAttributeSetHandler = 0;
+txHandlerTable* gTxFallbackHandler = 0;
+
+static nsresult txFnStartLRE(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix, txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState);
+static void txFnEndLRE(txStylesheetCompilerState& aState);
+
+#define TX_RETURN_IF_WHITESPACE(_str, _state) \
+ do { \
+ if (!_state.mElementContext->mPreserveWhitespace && \
+ XMLUtils::isWhitespace(_str)) { \
+ return NS_OK; \
+ } \
+ } while (0)
+
+static nsresult getStyleAttr(txStylesheetAttr* aAttributes, int32_t aAttrCount,
+ int32_t aNamespace, nsAtom* aName, bool aRequired,
+ txStylesheetAttr** aAttr) {
+ int32_t i;
+ for (i = 0; i < aAttrCount; ++i) {
+ txStylesheetAttr* attr = aAttributes + i;
+ if (attr->mNamespaceID == aNamespace && attr->mLocalName == aName) {
+ attr->mLocalName = nullptr;
+ *aAttr = attr;
+
+ return NS_OK;
+ }
+ }
+ *aAttr = nullptr;
+
+ if (aRequired) {
+ // XXX ErrorReport: missing required attribute
+ return NS_ERROR_XSLT_PARSE_FAILURE;
+ }
+
+ return NS_OK;
+}
+
+static nsresult parseUseAttrSets(txStylesheetAttr* aAttributes,
+ int32_t aAttrCount, bool aInXSLTNS,
+ txStylesheetCompilerState& aState) {
+ txStylesheetAttr* attr = nullptr;
+ nsresult rv = getStyleAttr(aAttributes, aAttrCount,
+ aInXSLTNS ? kNameSpaceID_XSLT : kNameSpaceID_None,
+ nsGkAtoms::useAttributeSets, false, &attr);
+ if (!attr) {
+ return rv;
+ }
+
+ nsWhitespaceTokenizer tok(attr->mValue);
+ while (tok.hasMoreTokens()) {
+ txExpandedName name;
+ rv = name.init(tok.nextToken(), aState.mElementContext->mMappings, false);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aState.addInstruction(MakeUnique<txInsertAttrSet>(name));
+ }
+ return NS_OK;
+}
+
+static nsresult parseExcludeResultPrefixes(txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ int32_t aNamespaceID) {
+ txStylesheetAttr* attr = nullptr;
+ nsresult rv = getStyleAttr(aAttributes, aAttrCount, aNamespaceID,
+ nsGkAtoms::excludeResultPrefixes, false, &attr);
+ if (!attr) {
+ return rv;
+ }
+
+ // XXX Needs to be implemented.
+
+ return NS_OK;
+}
+
+static nsresult getQNameAttr(txStylesheetAttr* aAttributes, int32_t aAttrCount,
+ nsAtom* aName, bool aRequired,
+ txStylesheetCompilerState& aState,
+ txExpandedName& aExpName) {
+ aExpName.reset();
+ txStylesheetAttr* attr = nullptr;
+ nsresult rv = getStyleAttr(aAttributes, aAttrCount, kNameSpaceID_None, aName,
+ aRequired, &attr);
+ if (!attr) {
+ return rv;
+ }
+
+ rv = aExpName.init(attr->mValue, aState.mElementContext->mMappings, false);
+ if (!aRequired && NS_FAILED(rv) && aState.fcp()) {
+ aExpName.reset();
+ rv = NS_OK;
+ }
+
+ return rv;
+}
+
+static nsresult getExprAttr(txStylesheetAttr* aAttributes, int32_t aAttrCount,
+ nsAtom* aName, bool aRequired,
+ txStylesheetCompilerState& aState,
+ UniquePtr<Expr>& aExpr) {
+ aExpr = nullptr;
+ txStylesheetAttr* attr = nullptr;
+ nsresult rv = getStyleAttr(aAttributes, aAttrCount, kNameSpaceID_None, aName,
+ aRequired, &attr);
+ if (!attr) {
+ return rv;
+ }
+
+ rv = txExprParser::createExpr(attr->mValue, &aState, getter_Transfers(aExpr));
+ if (NS_FAILED(rv) && aState.ignoreError(rv)) {
+ // use default value in fcp for not required exprs
+ if (aRequired) {
+ aExpr = MakeUnique<txErrorExpr>(
+#ifdef TX_TO_STRING
+ attr->mValue
+#endif
+ );
+ } else {
+ aExpr = nullptr;
+ }
+ return NS_OK;
+ }
+
+ return rv;
+}
+
+static nsresult getAVTAttr(txStylesheetAttr* aAttributes, int32_t aAttrCount,
+ nsAtom* aName, bool aRequired,
+ txStylesheetCompilerState& aState,
+ UniquePtr<Expr>& aAVT) {
+ aAVT = nullptr;
+ txStylesheetAttr* attr = nullptr;
+ nsresult rv = getStyleAttr(aAttributes, aAttrCount, kNameSpaceID_None, aName,
+ aRequired, &attr);
+ if (!attr) {
+ return rv;
+ }
+
+ rv = txExprParser::createAVT(attr->mValue, &aState, getter_Transfers(aAVT));
+ if (NS_FAILED(rv) && aState.fcp()) {
+ // use default value in fcp for not required exprs
+ if (aRequired) {
+ aAVT = MakeUnique<txErrorExpr>(
+#ifdef TX_TO_STRING
+ attr->mValue
+#endif
+ );
+ } else {
+ aAVT = nullptr;
+ }
+ return NS_OK;
+ }
+
+ return rv;
+}
+
+static nsresult getPatternAttr(txStylesheetAttr* aAttributes,
+ int32_t aAttrCount, nsAtom* aName,
+ bool aRequired,
+ txStylesheetCompilerState& aState,
+ UniquePtr<txPattern>& aPattern) {
+ aPattern = nullptr;
+ txStylesheetAttr* attr = nullptr;
+ nsresult rv = getStyleAttr(aAttributes, aAttrCount, kNameSpaceID_None, aName,
+ aRequired, &attr);
+ if (!attr) {
+ return rv;
+ }
+
+ rv = txPatternParser::createPattern(attr->mValue, &aState,
+ getter_Transfers(aPattern));
+ if (NS_FAILED(rv) && (aRequired || !aState.ignoreError(rv))) {
+ // XXX ErrorReport: XSLT-Pattern parse failure
+ return rv;
+ }
+
+ return NS_OK;
+}
+
+static nsresult getNumberAttr(txStylesheetAttr* aAttributes, int32_t aAttrCount,
+ nsAtom* aName, bool aRequired,
+ txStylesheetCompilerState& aState,
+ double& aNumber) {
+ aNumber = UnspecifiedNaN<double>();
+ txStylesheetAttr* attr = nullptr;
+ nsresult rv = getStyleAttr(aAttributes, aAttrCount, kNameSpaceID_None, aName,
+ aRequired, &attr);
+ if (!attr) {
+ return rv;
+ }
+
+ aNumber = txDouble::toDouble(attr->mValue);
+ if (std::isnan(aNumber) && (aRequired || !aState.fcp())) {
+ // XXX ErrorReport: number parse failure
+ return NS_ERROR_XSLT_PARSE_FAILURE;
+ }
+
+ return NS_OK;
+}
+
+static nsresult getAtomAttr(txStylesheetAttr* aAttributes, int32_t aAttrCount,
+ nsAtom* aName, bool aRequired,
+ txStylesheetCompilerState& aState, nsAtom** aAtom) {
+ *aAtom = nullptr;
+ txStylesheetAttr* attr = nullptr;
+ nsresult rv = getStyleAttr(aAttributes, aAttrCount, kNameSpaceID_None, aName,
+ aRequired, &attr);
+ if (!attr) {
+ return rv;
+ }
+
+ *aAtom = NS_Atomize(attr->mValue).take();
+ NS_ENSURE_TRUE(*aAtom, NS_ERROR_OUT_OF_MEMORY);
+
+ return NS_OK;
+}
+
+static nsresult getYesNoAttr(txStylesheetAttr* aAttributes, int32_t aAttrCount,
+ nsAtom* aName, bool aRequired,
+ txStylesheetCompilerState& aState,
+ txThreeState& aRes) {
+ aRes = eNotSet;
+ RefPtr<nsAtom> atom;
+ nsresult rv = getAtomAttr(aAttributes, aAttrCount, aName, aRequired, aState,
+ getter_AddRefs(atom));
+ if (!atom) {
+ return rv;
+ }
+
+ if (atom == nsGkAtoms::yes) {
+ aRes = eTrue;
+ } else if (atom == nsGkAtoms::no) {
+ aRes = eFalse;
+ } else if (aRequired || !aState.fcp()) {
+ // XXX ErrorReport: unknown values
+ return NS_ERROR_XSLT_PARSE_FAILURE;
+ }
+
+ return NS_OK;
+}
+
+static nsresult getCharAttr(txStylesheetAttr* aAttributes, int32_t aAttrCount,
+ nsAtom* aName, bool aRequired,
+ txStylesheetCompilerState& aState,
+ char16_t& aChar) {
+ // Don't reset aChar since it contains the default value
+ txStylesheetAttr* attr = nullptr;
+ nsresult rv = getStyleAttr(aAttributes, aAttrCount, kNameSpaceID_None, aName,
+ aRequired, &attr);
+ if (!attr) {
+ return rv;
+ }
+
+ if (attr->mValue.Length() == 1) {
+ aChar = attr->mValue.CharAt(0);
+ } else if (aRequired || !aState.fcp()) {
+ // XXX ErrorReport: not a character
+ return NS_ERROR_XSLT_PARSE_FAILURE;
+ }
+
+ return NS_OK;
+}
+
+static void pushInstruction(txStylesheetCompilerState& aState,
+ UniquePtr<txInstruction> aInstruction) {
+ aState.pushObject(aInstruction.release());
+}
+
+template <class T = txInstruction>
+static UniquePtr<T> popInstruction(txStylesheetCompilerState& aState) {
+ return UniquePtr<T>(static_cast<T*>(aState.popObject()));
+}
+
+/**
+ * Ignore and error handlers
+ */
+static nsresult txFnTextIgnore(const nsAString& aStr,
+ txStylesheetCompilerState& aState) {
+ return NS_OK;
+}
+
+static nsresult txFnTextError(const nsAString& aStr,
+ txStylesheetCompilerState& aState) {
+ TX_RETURN_IF_WHITESPACE(aStr, aState);
+
+ return NS_ERROR_XSLT_PARSE_FAILURE;
+}
+
+void clearAttributes(txStylesheetAttr* aAttributes, int32_t aAttrCount) {
+ int32_t i;
+ for (i = 0; i < aAttrCount; ++i) {
+ aAttributes[i].mLocalName = nullptr;
+ }
+}
+
+static nsresult txFnStartElementIgnore(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix,
+ txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ if (!aState.fcp()) {
+ clearAttributes(aAttributes, aAttrCount);
+ }
+
+ return NS_OK;
+}
+
+static void txFnEndElementIgnore(txStylesheetCompilerState& aState) {}
+
+static nsresult txFnStartElementSetIgnore(int32_t aNamespaceID,
+ nsAtom* aLocalName, nsAtom* aPrefix,
+ txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ if (!aState.fcp()) {
+ clearAttributes(aAttributes, aAttrCount);
+ }
+
+ aState.pushHandlerTable(gTxIgnoreHandler);
+
+ return NS_OK;
+}
+
+static void txFnEndElementSetIgnore(txStylesheetCompilerState& aState) {
+ aState.popHandlerTable();
+}
+
+static nsresult txFnStartElementError(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix,
+ txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ return NS_ERROR_XSLT_PARSE_FAILURE;
+}
+
+static void txFnEndElementError(txStylesheetCompilerState& aState) {
+ MOZ_CRASH("txFnEndElementError shouldn't be called");
+}
+
+/**
+ * Root handlers
+ */
+static nsresult txFnStartStylesheet(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix,
+ txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ // extension-element-prefixes is handled in
+ // txStylesheetCompiler::startElementInternal
+
+ txStylesheetAttr* attr;
+ nsresult rv = getStyleAttr(aAttributes, aAttrCount, kNameSpaceID_None,
+ nsGkAtoms::id, false, &attr);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = parseExcludeResultPrefixes(aAttributes, aAttrCount, kNameSpaceID_None);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = getStyleAttr(aAttributes, aAttrCount, kNameSpaceID_None,
+ nsGkAtoms::version, true, &attr);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aState.pushHandlerTable(gTxImportHandler);
+
+ return NS_OK;
+}
+
+static void txFnEndStylesheet(txStylesheetCompilerState& aState) {
+ aState.popHandlerTable();
+}
+
+static nsresult txFnStartElementContinueTopLevel(
+ int32_t aNamespaceID, nsAtom* aLocalName, nsAtom* aPrefix,
+ txStylesheetAttr* aAttributes, int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ aState.mHandlerTable = gTxTopHandler;
+
+ return NS_XSLT_GET_NEW_HANDLER;
+}
+
+static nsresult txFnStartLREStylesheet(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix,
+ txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ txStylesheetAttr* attr;
+ nsresult rv = getStyleAttr(aAttributes, aAttrCount, kNameSpaceID_XSLT,
+ nsGkAtoms::version, true, &attr);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ txExpandedName nullExpr;
+ double prio = UnspecifiedNaN<double>();
+
+ UniquePtr<txPattern> match(new txRootPattern());
+ UniquePtr<txTemplateItem> templ(
+ new txTemplateItem(std::move(match), nullExpr, nullExpr, prio));
+ aState.openInstructionContainer(templ.get());
+ aState.addToplevelItem(templ.release());
+
+ aState.pushHandlerTable(gTxTemplateHandler);
+
+ return txFnStartLRE(aNamespaceID, aLocalName, aPrefix, aAttributes,
+ aAttrCount, aState);
+}
+
+static void txFnEndLREStylesheet(txStylesheetCompilerState& aState) {
+ txFnEndLRE(aState);
+
+ aState.popHandlerTable();
+
+ aState.addInstruction(MakeUnique<txReturn>());
+
+ aState.closeInstructionContainer();
+}
+
+static nsresult txFnStartEmbed(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix, txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ if (!aState.handleEmbeddedSheet()) {
+ return NS_OK;
+ }
+ if (aNamespaceID != kNameSpaceID_XSLT ||
+ (aLocalName != nsGkAtoms::stylesheet &&
+ aLocalName != nsGkAtoms::transform)) {
+ return NS_ERROR_XSLT_PARSE_FAILURE;
+ }
+ return txFnStartStylesheet(aNamespaceID, aLocalName, aPrefix, aAttributes,
+ aAttrCount, aState);
+}
+
+static void txFnEndEmbed(txStylesheetCompilerState& aState) {
+ if (!aState.handleEmbeddedSheet()) {
+ return;
+ }
+ txFnEndStylesheet(aState);
+ aState.doneEmbedding();
+}
+
+/**
+ * Top handlers
+ */
+static nsresult txFnStartOtherTop(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix,
+ txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ if (aNamespaceID == kNameSpaceID_None ||
+ (aNamespaceID == kNameSpaceID_XSLT && !aState.fcp())) {
+ return NS_ERROR_XSLT_PARSE_FAILURE;
+ }
+
+ aState.pushHandlerTable(gTxIgnoreHandler);
+
+ return NS_OK;
+}
+
+static void txFnEndOtherTop(txStylesheetCompilerState& aState) {
+ aState.popHandlerTable();
+}
+
+// xsl:attribute-set
+static nsresult txFnStartAttributeSet(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix,
+ txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ nsresult rv = NS_OK;
+ txExpandedName name;
+ rv = getQNameAttr(aAttributes, aAttrCount, nsGkAtoms::name, true, aState,
+ name);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ UniquePtr<txAttributeSetItem> attrSet(new txAttributeSetItem(name));
+ aState.openInstructionContainer(attrSet.get());
+
+ aState.addToplevelItem(attrSet.release());
+
+ rv = parseUseAttrSets(aAttributes, aAttrCount, false, aState);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aState.pushHandlerTable(gTxAttributeSetHandler);
+
+ return NS_OK;
+}
+
+static void txFnEndAttributeSet(txStylesheetCompilerState& aState) {
+ aState.popHandlerTable();
+
+ aState.addInstruction(MakeUnique<txReturn>());
+
+ aState.closeInstructionContainer();
+}
+
+// xsl:decimal-format
+static nsresult txFnStartDecimalFormat(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix,
+ txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ nsresult rv = NS_OK;
+ txExpandedName name;
+ rv = getQNameAttr(aAttributes, aAttrCount, nsGkAtoms::name, false, aState,
+ name);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ UniquePtr<txDecimalFormat> format(new txDecimalFormat);
+ rv = getCharAttr(aAttributes, aAttrCount, nsGkAtoms::decimalSeparator, false,
+ aState, format->mDecimalSeparator);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = getCharAttr(aAttributes, aAttrCount, nsGkAtoms::groupingSeparator, false,
+ aState, format->mGroupingSeparator);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ txStylesheetAttr* attr = nullptr;
+ rv = getStyleAttr(aAttributes, aAttrCount, kNameSpaceID_None,
+ nsGkAtoms::infinity, false, &attr);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (attr) {
+ format->mInfinity = attr->mValue;
+ }
+
+ rv = getCharAttr(aAttributes, aAttrCount, nsGkAtoms::minusSign, false, aState,
+ format->mMinusSign);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = getStyleAttr(aAttributes, aAttrCount, kNameSpaceID_None, nsGkAtoms::NaN,
+ false, &attr);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (attr) {
+ format->mNaN = attr->mValue;
+ }
+
+ rv = getCharAttr(aAttributes, aAttrCount, nsGkAtoms::percent, false, aState,
+ format->mPercent);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = getCharAttr(aAttributes, aAttrCount, nsGkAtoms::perMille, false, aState,
+ format->mPerMille);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = getCharAttr(aAttributes, aAttrCount, nsGkAtoms::zeroDigit, false, aState,
+ format->mZeroDigit);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = getCharAttr(aAttributes, aAttrCount, nsGkAtoms::digit, false, aState,
+ format->mDigit);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = getCharAttr(aAttributes, aAttrCount, nsGkAtoms::patternSeparator, false,
+ aState, format->mPatternSeparator);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = aState.mStylesheet->addDecimalFormat(name, std::move(format));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aState.pushHandlerTable(gTxIgnoreHandler);
+
+ return NS_OK;
+}
+
+static void txFnEndDecimalFormat(txStylesheetCompilerState& aState) {
+ aState.popHandlerTable();
+}
+
+// xsl:import
+static nsresult txFnStartImport(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix, txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ UniquePtr<txImportItem> import(new txImportItem);
+ import->mFrame = MakeUnique<txStylesheet::ImportFrame>();
+ txStylesheet::ImportFrame* frame = import->mFrame.get();
+ aState.addToplevelItem(import.release());
+
+ txStylesheetAttr* attr = nullptr;
+ nsresult rv = getStyleAttr(aAttributes, aAttrCount, kNameSpaceID_None,
+ nsGkAtoms::href, true, &attr);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ nsAutoString absUri;
+ URIUtils::resolveHref(attr->mValue, aState.mElementContext->mBaseURI, absUri);
+ rv = aState.loadImportedStylesheet(absUri, frame);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aState.pushHandlerTable(gTxIgnoreHandler);
+
+ return NS_OK;
+}
+
+static void txFnEndImport(txStylesheetCompilerState& aState) {
+ aState.popHandlerTable();
+}
+
+// xsl:include
+static nsresult txFnStartInclude(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix, txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ txStylesheetAttr* attr = nullptr;
+ nsresult rv = getStyleAttr(aAttributes, aAttrCount, kNameSpaceID_None,
+ nsGkAtoms::href, true, &attr);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ nsAutoString absUri;
+ URIUtils::resolveHref(attr->mValue, aState.mElementContext->mBaseURI, absUri);
+ rv = aState.loadIncludedStylesheet(absUri);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aState.pushHandlerTable(gTxIgnoreHandler);
+
+ return NS_OK;
+}
+
+static void txFnEndInclude(txStylesheetCompilerState& aState) {
+ aState.popHandlerTable();
+}
+
+// xsl:key
+static nsresult txFnStartKey(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix, txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ nsresult rv = NS_OK;
+ txExpandedName name;
+ rv = getQNameAttr(aAttributes, aAttrCount, nsGkAtoms::name, true, aState,
+ name);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aState.mDisAllowed = txIParseContext::KEY_FUNCTION;
+
+ UniquePtr<txPattern> match;
+ rv = getPatternAttr(aAttributes, aAttrCount, nsGkAtoms::match, true, aState,
+ match);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ UniquePtr<Expr> use;
+ rv = getExprAttr(aAttributes, aAttrCount, nsGkAtoms::use, true, aState, use);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aState.mDisAllowed = 0;
+
+ rv = aState.mStylesheet->addKey(name, std::move(match), std::move(use));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aState.pushHandlerTable(gTxIgnoreHandler);
+
+ return NS_OK;
+}
+
+static void txFnEndKey(txStylesheetCompilerState& aState) {
+ aState.popHandlerTable();
+}
+
+// xsl:namespace-alias
+static nsresult txFnStartNamespaceAlias(int32_t aNamespaceID,
+ nsAtom* aLocalName, nsAtom* aPrefix,
+ txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ txStylesheetAttr* attr = nullptr;
+ nsresult rv = getStyleAttr(aAttributes, aAttrCount, kNameSpaceID_None,
+ nsGkAtoms::stylesheetPrefix, true, &attr);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = getStyleAttr(aAttributes, aAttrCount, kNameSpaceID_None,
+ nsGkAtoms::resultPrefix, true, &attr);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // XXX Needs to be implemented.
+
+ aState.pushHandlerTable(gTxIgnoreHandler);
+
+ return NS_OK;
+}
+
+static void txFnEndNamespaceAlias(txStylesheetCompilerState& aState) {
+ aState.popHandlerTable();
+}
+
+// xsl:output
+static nsresult txFnStartOutput(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix, txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ nsresult rv = NS_OK;
+
+ UniquePtr<txOutputItem> item(new txOutputItem);
+
+ txExpandedName methodExpName;
+ rv = getQNameAttr(aAttributes, aAttrCount, nsGkAtoms::method, false, aState,
+ methodExpName);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (!methodExpName.isNull()) {
+ if (methodExpName.mNamespaceID != kNameSpaceID_None) {
+ // The spec doesn't say what to do here so we'll just ignore the
+ // value. We could possibly warn.
+ } else if (methodExpName.mLocalName == nsGkAtoms::html) {
+ item->mFormat.mMethod = eHTMLOutput;
+ } else if (methodExpName.mLocalName == nsGkAtoms::text) {
+ item->mFormat.mMethod = eTextOutput;
+ } else if (methodExpName.mLocalName == nsGkAtoms::xml) {
+ item->mFormat.mMethod = eXMLOutput;
+ } else {
+ return NS_ERROR_XSLT_PARSE_FAILURE;
+ }
+ }
+
+ txStylesheetAttr* attr = nullptr;
+ getStyleAttr(aAttributes, aAttrCount, kNameSpaceID_None, nsGkAtoms::version,
+ false, &attr);
+ if (attr) {
+ item->mFormat.mVersion = attr->mValue;
+ }
+
+ getStyleAttr(aAttributes, aAttrCount, kNameSpaceID_None, nsGkAtoms::encoding,
+ false, &attr);
+ if (attr) {
+ item->mFormat.mEncoding = attr->mValue;
+ }
+
+ rv = getYesNoAttr(aAttributes, aAttrCount, nsGkAtoms::omitXmlDeclaration,
+ false, aState, item->mFormat.mOmitXMLDeclaration);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = getYesNoAttr(aAttributes, aAttrCount, nsGkAtoms::standalone, false,
+ aState, item->mFormat.mStandalone);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ getStyleAttr(aAttributes, aAttrCount, kNameSpaceID_None,
+ nsGkAtoms::doctypePublic, false, &attr);
+ if (attr) {
+ item->mFormat.mPublicId = attr->mValue;
+ }
+
+ getStyleAttr(aAttributes, aAttrCount, kNameSpaceID_None,
+ nsGkAtoms::doctypeSystem, false, &attr);
+ if (attr) {
+ item->mFormat.mSystemId = attr->mValue;
+ }
+
+ getStyleAttr(aAttributes, aAttrCount, kNameSpaceID_None,
+ nsGkAtoms::cdataSectionElements, false, &attr);
+ if (attr) {
+ nsWhitespaceTokenizer tokens(attr->mValue);
+ while (tokens.hasMoreTokens()) {
+ UniquePtr<txExpandedName> qname(new txExpandedName());
+ rv = qname->init(tokens.nextToken(), aState.mElementContext->mMappings,
+ false);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ item->mFormat.mCDATASectionElements.add(qname.release());
+ }
+ }
+
+ rv = getYesNoAttr(aAttributes, aAttrCount, nsGkAtoms::indent, false, aState,
+ item->mFormat.mIndent);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ getStyleAttr(aAttributes, aAttrCount, kNameSpaceID_None, nsGkAtoms::mediaType,
+ false, &attr);
+ if (attr) {
+ item->mFormat.mMediaType = NS_ConvertUTF16toUTF8(attr->mValue);
+ }
+
+ aState.addToplevelItem(item.release());
+
+ aState.pushHandlerTable(gTxIgnoreHandler);
+
+ return NS_OK;
+}
+
+static void txFnEndOutput(txStylesheetCompilerState& aState) {
+ aState.popHandlerTable();
+}
+
+// xsl:strip-space/xsl:preserve-space
+static nsresult txFnStartStripSpace(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix,
+ txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ txStylesheetAttr* attr = nullptr;
+ nsresult rv = getStyleAttr(aAttributes, aAttrCount, kNameSpaceID_None,
+ nsGkAtoms::elements, true, &attr);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ bool strip = aLocalName == nsGkAtoms::stripSpace;
+
+ UniquePtr<txStripSpaceItem> stripItem(new txStripSpaceItem);
+ nsWhitespaceTokenizer tokenizer(attr->mValue);
+ while (tokenizer.hasMoreTokens()) {
+ const nsAString& name = tokenizer.nextToken();
+ int32_t ns = kNameSpaceID_None;
+ RefPtr<nsAtom> prefix, localName;
+ rv = XMLUtils::splitQName(name, getter_AddRefs(prefix),
+ getter_AddRefs(localName));
+ if (NS_FAILED(rv)) {
+ // check for "*" or "prefix:*"
+ uint32_t length = name.Length();
+ const char16_t* c;
+ name.BeginReading(c);
+ if (length == 2 || c[length - 1] != '*') {
+ // these can't work
+ return NS_ERROR_XSLT_PARSE_FAILURE;
+ }
+ if (length > 1) {
+ // Check for a valid prefix, that is, the returned prefix
+ // should be empty and the real prefix is returned in
+ // localName.
+ if (c[length - 2] != ':') {
+ return NS_ERROR_XSLT_PARSE_FAILURE;
+ }
+ rv = XMLUtils::splitQName(StringHead(name, length - 2),
+ getter_AddRefs(prefix),
+ getter_AddRefs(localName));
+ if (NS_FAILED(rv) || prefix) {
+ // bad chars or two ':'
+ return NS_ERROR_XSLT_PARSE_FAILURE;
+ }
+ prefix = localName;
+ }
+ localName = nsGkAtoms::_asterisk;
+ }
+ if (prefix) {
+ ns = aState.mElementContext->mMappings->lookupNamespace(prefix);
+ NS_ENSURE_TRUE(ns != kNameSpaceID_Unknown, NS_ERROR_FAILURE);
+ }
+ stripItem->addStripSpaceTest(
+ new txStripSpaceTest(prefix, localName, ns, strip));
+ }
+
+ aState.addToplevelItem(stripItem.release());
+
+ aState.pushHandlerTable(gTxIgnoreHandler);
+
+ return NS_OK;
+}
+
+static void txFnEndStripSpace(txStylesheetCompilerState& aState) {
+ aState.popHandlerTable();
+}
+
+// xsl:template
+static nsresult txFnStartTemplate(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix,
+ txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ nsresult rv = NS_OK;
+ txExpandedName name;
+ rv = getQNameAttr(aAttributes, aAttrCount, nsGkAtoms::name, false, aState,
+ name);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ txExpandedName mode;
+ rv = getQNameAttr(aAttributes, aAttrCount, nsGkAtoms::mode, false, aState,
+ mode);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ double prio = UnspecifiedNaN<double>();
+ rv = getNumberAttr(aAttributes, aAttrCount, nsGkAtoms::priority, false,
+ aState, prio);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ UniquePtr<txPattern> match;
+ rv = getPatternAttr(aAttributes, aAttrCount, nsGkAtoms::match, name.isNull(),
+ aState, match);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ UniquePtr<txTemplateItem> templ(
+ new txTemplateItem(std::move(match), name, mode, prio));
+ aState.openInstructionContainer(templ.get());
+ aState.addToplevelItem(templ.release());
+
+ aState.pushHandlerTable(gTxParamHandler);
+
+ return NS_OK;
+}
+
+static void txFnEndTemplate(txStylesheetCompilerState& aState) {
+ aState.popHandlerTable();
+
+ aState.addInstruction(MakeUnique<txReturn>());
+
+ aState.closeInstructionContainer();
+}
+
+// xsl:variable, xsl:param
+static nsresult txFnStartTopVariable(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix,
+ txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ nsresult rv = NS_OK;
+ txExpandedName name;
+ rv = getQNameAttr(aAttributes, aAttrCount, nsGkAtoms::name, true, aState,
+ name);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ UniquePtr<Expr> select;
+ rv = getExprAttr(aAttributes, aAttrCount, nsGkAtoms::select, false, aState,
+ select);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ UniquePtr<txVariableItem> var(new txVariableItem(
+ name, std::move(select), aLocalName == nsGkAtoms::param));
+ aState.openInstructionContainer(var.get());
+ aState.pushPtr(var.get(), aState.eVariableItem);
+
+ if (var->mValue) {
+ // XXX should be gTxErrorHandler?
+ aState.pushHandlerTable(gTxIgnoreHandler);
+ } else {
+ aState.pushHandlerTable(gTxTopVariableHandler);
+ }
+
+ aState.addToplevelItem(var.release());
+
+ return NS_OK;
+}
+
+static void txFnEndTopVariable(txStylesheetCompilerState& aState) {
+ txHandlerTable* prev = aState.mHandlerTable;
+ aState.popHandlerTable();
+ txVariableItem* var =
+ static_cast<txVariableItem*>(aState.popPtr(aState.eVariableItem));
+
+ if (prev == gTxTopVariableHandler) {
+ // No children were found.
+ NS_ASSERTION(!var->mValue, "There shouldn't be a select-expression here");
+ var->mValue = MakeUnique<txLiteralExpr>(u""_ns);
+ } else if (!var->mValue) {
+ // If we don't have a select-expression there mush be children.
+ aState.addInstruction(MakeUnique<txReturn>());
+ }
+
+ aState.closeInstructionContainer();
+}
+
+static nsresult txFnStartElementStartTopVar(int32_t aNamespaceID,
+ nsAtom* aLocalName, nsAtom* aPrefix,
+ txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ aState.mHandlerTable = gTxTemplateHandler;
+
+ return NS_XSLT_GET_NEW_HANDLER;
+}
+
+static nsresult txFnTextStartTopVar(const nsAString& aStr,
+ txStylesheetCompilerState& aState) {
+ TX_RETURN_IF_WHITESPACE(aStr, aState);
+
+ aState.mHandlerTable = gTxTemplateHandler;
+
+ return NS_XSLT_GET_NEW_HANDLER;
+}
+
+/**
+ * Template Handlers
+ */
+
+/*
+ LRE
+
+ txStartLREElement
+ txInsertAttrSet one for each qname in xsl:use-attribute-sets
+ txLREAttribute one for each attribute
+ [children]
+ txEndElement
+*/
+static nsresult txFnStartLRE(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix, txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ nsresult rv = NS_OK;
+
+ aState.addInstruction(
+ MakeUnique<txStartLREElement>(aNamespaceID, aLocalName, aPrefix));
+
+ rv = parseExcludeResultPrefixes(aAttributes, aAttrCount, kNameSpaceID_XSLT);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = parseUseAttrSets(aAttributes, aAttrCount, true, aState);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ txStylesheetAttr* attr = nullptr;
+ int32_t i;
+ for (i = 0; i < aAttrCount; ++i) {
+ attr = aAttributes + i;
+
+ if (attr->mNamespaceID == kNameSpaceID_XSLT) {
+ if (attr->mLocalName == nsGkAtoms::version) {
+ attr->mLocalName = nullptr;
+ }
+
+ continue;
+ }
+
+ UniquePtr<Expr> avt;
+ rv = txExprParser::createAVT(attr->mValue, &aState, getter_Transfers(avt));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aState.addInstruction(MakeUnique<txLREAttribute>(
+ attr->mNamespaceID, attr->mLocalName, attr->mPrefix, std::move(avt)));
+ }
+
+ return NS_OK;
+}
+
+static void txFnEndLRE(txStylesheetCompilerState& aState) {
+ aState.addInstruction(MakeUnique<txEndElement>());
+}
+
+/*
+ "LRE text"
+
+ txText
+*/
+static nsresult txFnText(const nsAString& aStr,
+ txStylesheetCompilerState& aState) {
+ TX_RETURN_IF_WHITESPACE(aStr, aState);
+
+ aState.addInstruction(MakeUnique<txText>(aStr, false));
+
+ return NS_OK;
+}
+
+/*
+ xsl:apply-imports
+
+ txApplyImportsStart
+ txApplyImportsEnd
+*/
+static nsresult txFnStartApplyImports(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix,
+ txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ aState.addInstruction(MakeUnique<txApplyImportsStart>());
+ aState.addInstruction(MakeUnique<txApplyImportsEnd>());
+
+ aState.pushHandlerTable(gTxIgnoreHandler);
+
+ return NS_OK;
+}
+
+static void txFnEndApplyImports(txStylesheetCompilerState& aState) {
+ aState.popHandlerTable();
+}
+
+/*
+ xsl:apply-templates
+
+ txPushParams
+ [params]
+ txPushNewContext -+ (holds <xsl:sort>s)
+ txApplyTemplate <-+ |
+ txLoopNodeSet -+ |
+ txPopParams <-+
+*/
+static nsresult txFnStartApplyTemplates(int32_t aNamespaceID,
+ nsAtom* aLocalName, nsAtom* aPrefix,
+ txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ nsresult rv = NS_OK;
+
+ aState.addInstruction(MakeUnique<txPushParams>());
+
+ txExpandedName mode;
+ rv = getQNameAttr(aAttributes, aAttrCount, nsGkAtoms::mode, false, aState,
+ mode);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ pushInstruction(aState, MakeUnique<txApplyTemplates>(mode));
+
+ UniquePtr<Expr> select;
+ rv = getExprAttr(aAttributes, aAttrCount, nsGkAtoms::select, false, aState,
+ select);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (!select) {
+ UniquePtr<txNodeTest> nt(new txNodeTypeTest(txNodeTypeTest::NODE_TYPE));
+ select = MakeUnique<LocationStep>(nt.release(), LocationStep::CHILD_AXIS);
+ }
+
+ UniquePtr<txPushNewContext> pushcontext(
+ new txPushNewContext(std::move(select)));
+ aState.pushSorter(pushcontext.get());
+ pushInstruction(aState, std::move(pushcontext));
+
+ aState.pushHandlerTable(gTxApplyTemplatesHandler);
+
+ return NS_OK;
+}
+
+static void txFnEndApplyTemplates(txStylesheetCompilerState& aState) {
+ aState.popHandlerTable();
+
+ txPushNewContext* pushcontext =
+ aState.addInstruction(popInstruction<txPushNewContext>(aState));
+
+ aState.popSorter();
+
+ // txApplyTemplates
+ txInstruction* instr = aState.addInstruction(popInstruction(aState));
+ aState.addInstruction(MakeUnique<txLoopNodeSet>(instr));
+
+ pushcontext->mBailTarget = aState.addInstruction(MakeUnique<txPopParams>());
+}
+
+/*
+ xsl:attribute
+
+ txPushStringHandler
+ [children]
+ txAttribute
+*/
+static nsresult txFnStartAttribute(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix,
+ txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ nsresult rv = NS_OK;
+
+ aState.addInstruction(MakeUnique<txPushStringHandler>(true));
+
+ UniquePtr<Expr> name;
+ rv = getAVTAttr(aAttributes, aAttrCount, nsGkAtoms::name, true, aState, name);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ UniquePtr<Expr> nspace;
+ rv = getAVTAttr(aAttributes, aAttrCount, nsGkAtoms::_namespace, false, aState,
+ nspace);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ pushInstruction(aState,
+ MakeUnique<txAttribute>(std::move(name), std::move(nspace),
+ aState.mElementContext->mMappings));
+
+ // We need to push the template-handler since the current might be
+ // the attributeset-handler
+ aState.pushHandlerTable(gTxTemplateHandler);
+
+ return NS_OK;
+}
+
+static void txFnEndAttribute(txStylesheetCompilerState& aState) {
+ aState.popHandlerTable();
+ aState.addInstruction(popInstruction(aState));
+}
+
+/*
+ xsl:call-template
+
+ txPushParams
+ [params]
+ txCallTemplate
+ txPopParams
+*/
+static nsresult txFnStartCallTemplate(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix,
+ txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ nsresult rv = NS_OK;
+
+ aState.addInstruction(MakeUnique<txPushParams>());
+
+ txExpandedName name;
+ rv = getQNameAttr(aAttributes, aAttrCount, nsGkAtoms::name, true, aState,
+ name);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ pushInstruction(aState, MakeUnique<txCallTemplate>(name));
+
+ aState.pushHandlerTable(gTxCallTemplateHandler);
+
+ return NS_OK;
+}
+
+static void txFnEndCallTemplate(txStylesheetCompilerState& aState) {
+ aState.popHandlerTable();
+
+ // txCallTemplate
+ aState.addInstruction(popInstruction(aState));
+
+ aState.addInstruction(MakeUnique<txPopParams>());
+}
+
+/*
+ xsl:choose
+
+ txCondotionalGoto --+ \
+ [children] | | one for each xsl:when
+ txGoTo --+ | /
+ | |
+ txCondotionalGoto | <-+ --+
+ [children] | |
+ txGoTo --+ |
+ | |
+ [children] | <-+ for the xsl:otherwise, if there is one
+ <-+
+*/
+static nsresult txFnStartChoose(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix, txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ aState.pushChooseGotoList();
+
+ aState.pushHandlerTable(gTxChooseHandler);
+
+ return NS_OK;
+}
+
+static void txFnEndChoose(txStylesheetCompilerState& aState) {
+ aState.popHandlerTable();
+ txListIterator iter(aState.mChooseGotoList.get());
+ txGoTo* gotoinstr;
+ while ((gotoinstr = static_cast<txGoTo*>(iter.next()))) {
+ aState.addGotoTarget(&gotoinstr->mTarget);
+ }
+
+ aState.popChooseGotoList();
+}
+
+/*
+ xsl:comment
+
+ txPushStringHandler
+ [children]
+ txComment
+*/
+static nsresult txFnStartComment(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix, txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ aState.addInstruction(MakeUnique<txPushStringHandler>(true));
+
+ return NS_OK;
+}
+
+static void txFnEndComment(txStylesheetCompilerState& aState) {
+ aState.addInstruction(MakeUnique<txComment>());
+}
+
+/*
+ xsl:copy
+
+ txCopy -+
+ txInsertAttrSet | one for each qname in use-attribute-sets
+ [children] |
+ txEndElement |
+ <-+
+*/
+static nsresult txFnStartCopy(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix, txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ aState.pushPtr(aState.addInstruction(MakeUnique<txCopy>()), aState.eCopy);
+
+ return parseUseAttrSets(aAttributes, aAttrCount, false, aState);
+}
+
+static void txFnEndCopy(txStylesheetCompilerState& aState) {
+ aState.addInstruction(MakeUnique<txEndElement>());
+
+ txCopy* copy = static_cast<txCopy*>(aState.popPtr(aState.eCopy));
+ aState.addGotoTarget(&copy->mBailTarget);
+}
+
+/*
+ xsl:copy-of
+
+ txCopyOf
+*/
+static nsresult txFnStartCopyOf(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix, txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ nsresult rv = NS_OK;
+
+ UniquePtr<Expr> select;
+ rv = getExprAttr(aAttributes, aAttrCount, nsGkAtoms::select, true, aState,
+ select);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aState.addInstruction(MakeUnique<txCopyOf>(std::move(select)));
+
+ aState.pushHandlerTable(gTxIgnoreHandler);
+
+ return NS_OK;
+}
+
+static void txFnEndCopyOf(txStylesheetCompilerState& aState) {
+ aState.popHandlerTable();
+}
+
+/*
+ xsl:element
+
+ txStartElement
+ txInsertAttrSet one for each qname in use-attribute-sets
+ [children]
+ txEndElement
+*/
+static nsresult txFnStartElement(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix, txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ nsresult rv = NS_OK;
+
+ UniquePtr<Expr> name;
+ rv = getAVTAttr(aAttributes, aAttrCount, nsGkAtoms::name, true, aState, name);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ UniquePtr<Expr> nspace;
+ rv = getAVTAttr(aAttributes, aAttrCount, nsGkAtoms::_namespace, false, aState,
+ nspace);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aState.addInstruction(MakeUnique<txStartElement>(
+ std::move(name), std::move(nspace), aState.mElementContext->mMappings));
+
+ rv = parseUseAttrSets(aAttributes, aAttrCount, false, aState);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ return NS_OK;
+}
+
+static void txFnEndElement(txStylesheetCompilerState& aState) {
+ aState.addInstruction(MakeUnique<txEndElement>());
+}
+
+/*
+ xsl:fallback
+
+ [children]
+*/
+static nsresult txFnStartFallback(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix,
+ txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ aState.mSearchingForFallback = false;
+
+ aState.pushHandlerTable(gTxTemplateHandler);
+
+ return NS_OK;
+}
+
+static void txFnEndFallback(txStylesheetCompilerState& aState) {
+ aState.popHandlerTable();
+
+ NS_ASSERTION(!aState.mSearchingForFallback,
+ "bad nesting of unknown-instruction and fallback handlers");
+}
+
+/*
+ xsl:for-each
+
+ txPushNewContext -+ (holds <xsl:sort>s)
+ txPushNullTemplateRule <-+ |
+ [children] | |
+ txLoopNodeSet -+ |
+ <-+
+*/
+static nsresult txFnStartForEach(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix, txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ nsresult rv = NS_OK;
+
+ UniquePtr<Expr> select;
+ rv = getExprAttr(aAttributes, aAttrCount, nsGkAtoms::select, true, aState,
+ select);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ txPushNewContext* pushcontext =
+ aState.addInstruction(MakeUnique<txPushNewContext>(std::move(select)));
+ aState.pushPtr(pushcontext, aState.ePushNewContext);
+ aState.pushSorter(pushcontext);
+
+ aState.pushPtr(aState.addInstruction(MakeUnique<txPushNullTemplateRule>()),
+ aState.ePushNullTemplateRule);
+
+ aState.pushHandlerTable(gTxForEachHandler);
+
+ return NS_OK;
+}
+
+static void txFnEndForEach(txStylesheetCompilerState& aState) {
+ aState.popHandlerTable();
+
+ // This is a txPushNullTemplateRule
+ txInstruction* pnullrule =
+ static_cast<txInstruction*>(aState.popPtr(aState.ePushNullTemplateRule));
+
+ aState.addInstruction(MakeUnique<txLoopNodeSet>(pnullrule));
+
+ aState.popSorter();
+ txPushNewContext* pushcontext =
+ static_cast<txPushNewContext*>(aState.popPtr(aState.ePushNewContext));
+ aState.addGotoTarget(&pushcontext->mBailTarget);
+}
+
+static nsresult txFnStartElementContinueTemplate(
+ int32_t aNamespaceID, nsAtom* aLocalName, nsAtom* aPrefix,
+ txStylesheetAttr* aAttributes, int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ aState.mHandlerTable = gTxTemplateHandler;
+
+ return NS_XSLT_GET_NEW_HANDLER;
+}
+
+static nsresult txFnTextContinueTemplate(const nsAString& aStr,
+ txStylesheetCompilerState& aState) {
+ TX_RETURN_IF_WHITESPACE(aStr, aState);
+
+ aState.mHandlerTable = gTxTemplateHandler;
+
+ return NS_XSLT_GET_NEW_HANDLER;
+}
+
+/*
+ xsl:if
+
+ txConditionalGoto -+
+ [children] |
+ <-+
+*/
+static nsresult txFnStartIf(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix, txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ nsresult rv = NS_OK;
+
+ UniquePtr<Expr> test;
+ rv =
+ getExprAttr(aAttributes, aAttrCount, nsGkAtoms::test, true, aState, test);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aState.pushPtr(aState.addInstruction(
+ MakeUnique<txConditionalGoto>(std::move(test), nullptr)),
+ aState.eConditionalGoto);
+
+ return NS_OK;
+}
+
+static void txFnEndIf(txStylesheetCompilerState& aState) {
+ txConditionalGoto* condGoto =
+ static_cast<txConditionalGoto*>(aState.popPtr(aState.eConditionalGoto));
+ aState.addGotoTarget(&condGoto->mTarget);
+}
+
+/*
+ xsl:message
+
+ txPushStringHandler
+ [children]
+ txMessage
+*/
+static nsresult txFnStartMessage(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix, txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ aState.addInstruction(MakeUnique<txPushStringHandler>(false));
+
+ txThreeState term;
+ nsresult rv = getYesNoAttr(aAttributes, aAttrCount, nsGkAtoms::terminate,
+ false, aState, term);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ pushInstruction(aState, MakeUnique<txMessage>(term == eTrue));
+
+ return NS_OK;
+}
+
+static void txFnEndMessage(txStylesheetCompilerState& aState) {
+ aState.addInstruction(popInstruction(aState));
+}
+
+/*
+ xsl:number
+
+ txNumber
+*/
+static nsresult txFnStartNumber(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix, txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ nsresult rv = NS_OK;
+
+ RefPtr<nsAtom> levelAtom;
+ rv = getAtomAttr(aAttributes, aAttrCount, nsGkAtoms::level, false, aState,
+ getter_AddRefs(levelAtom));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ txXSLTNumber::LevelType level = txXSLTNumber::eLevelSingle;
+ if (levelAtom == nsGkAtoms::multiple) {
+ level = txXSLTNumber::eLevelMultiple;
+ } else if (levelAtom == nsGkAtoms::any) {
+ level = txXSLTNumber::eLevelAny;
+ } else if (levelAtom && levelAtom != nsGkAtoms::single && !aState.fcp()) {
+ return NS_ERROR_XSLT_PARSE_FAILURE;
+ }
+
+ UniquePtr<txPattern> count;
+ rv = getPatternAttr(aAttributes, aAttrCount, nsGkAtoms::count, false, aState,
+ count);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ UniquePtr<txPattern> from;
+ rv = getPatternAttr(aAttributes, aAttrCount, nsGkAtoms::from, false, aState,
+ from);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ UniquePtr<Expr> value;
+ rv = getExprAttr(aAttributes, aAttrCount, nsGkAtoms::value, false, aState,
+ value);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ UniquePtr<Expr> format;
+ rv = getAVTAttr(aAttributes, aAttrCount, nsGkAtoms::format, false, aState,
+ format);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ UniquePtr<Expr> lang;
+ rv =
+ getAVTAttr(aAttributes, aAttrCount, nsGkAtoms::lang, false, aState, lang);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ UniquePtr<Expr> letterValue;
+ rv = getAVTAttr(aAttributes, aAttrCount, nsGkAtoms::letterValue, false,
+ aState, letterValue);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ UniquePtr<Expr> groupingSeparator;
+ rv = getAVTAttr(aAttributes, aAttrCount, nsGkAtoms::groupingSeparator, false,
+ aState, groupingSeparator);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ UniquePtr<Expr> groupingSize;
+ rv = getAVTAttr(aAttributes, aAttrCount, nsGkAtoms::groupingSize, false,
+ aState, groupingSize);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aState.addInstruction(MakeUnique<txNumber>(
+ level, std::move(count), std::move(from), std::move(value),
+ std::move(format), std::move(groupingSeparator),
+ std::move(groupingSize)));
+
+ aState.pushHandlerTable(gTxIgnoreHandler);
+
+ return NS_OK;
+}
+
+static void txFnEndNumber(txStylesheetCompilerState& aState) {
+ aState.popHandlerTable();
+}
+
+/*
+ xsl:otherwise
+
+ (see xsl:choose)
+*/
+static nsresult txFnStartOtherwise(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix,
+ txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ aState.pushHandlerTable(gTxTemplateHandler);
+
+ return NS_OK;
+}
+
+static void txFnEndOtherwise(txStylesheetCompilerState& aState) {
+ aState.popHandlerTable();
+ aState.mHandlerTable = gTxIgnoreHandler; // XXX should be gTxErrorHandler
+}
+
+/*
+ xsl:param
+
+ txCheckParam --+
+ txPushRTFHandler | --- (for RTF-parameters)
+ [children] | /
+ txSetVariable |
+ <-+
+*/
+static nsresult txFnStartParam(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix, txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ nsresult rv = NS_OK;
+
+ txExpandedName name;
+ rv = getQNameAttr(aAttributes, aAttrCount, nsGkAtoms::name, true, aState,
+ name);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aState.pushPtr(aState.addInstruction(MakeUnique<txCheckParam>(name)),
+ aState.eCheckParam);
+
+ UniquePtr<Expr> select;
+ rv = getExprAttr(aAttributes, aAttrCount, nsGkAtoms::select, false, aState,
+ select);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ UniquePtr<txSetVariable> var =
+ MakeUnique<txSetVariable>(name, std::move(select));
+ if (var->mValue) {
+ // XXX should be gTxErrorHandler?
+ aState.pushHandlerTable(gTxIgnoreHandler);
+ } else {
+ aState.pushHandlerTable(gTxVariableHandler);
+ }
+
+ pushInstruction(aState, std::move(var));
+
+ return NS_OK;
+}
+
+static void txFnEndParam(txStylesheetCompilerState& aState) {
+ UniquePtr<txSetVariable> var = popInstruction<txSetVariable>(aState);
+ txHandlerTable* prev = aState.mHandlerTable;
+ aState.popHandlerTable();
+
+ if (prev == gTxVariableHandler) {
+ // No children were found.
+ NS_ASSERTION(!var->mValue, "There shouldn't be a select-expression here");
+ var->mValue = MakeUnique<txLiteralExpr>(u""_ns);
+ }
+
+ aState.addVariable(var->mName);
+
+ aState.addInstruction(std::move(var));
+
+ txCheckParam* checkParam =
+ static_cast<txCheckParam*>(aState.popPtr(aState.eCheckParam));
+ aState.addGotoTarget(&checkParam->mBailTarget);
+}
+
+/*
+ xsl:processing-instruction
+
+ txPushStringHandler
+ [children]
+ txProcessingInstruction
+*/
+static nsresult txFnStartPI(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix, txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ aState.addInstruction(MakeUnique<txPushStringHandler>(true));
+
+ UniquePtr<Expr> name;
+ nsresult rv =
+ getAVTAttr(aAttributes, aAttrCount, nsGkAtoms::name, true, aState, name);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ pushInstruction(aState, MakeUnique<txProcessingInstruction>(std::move(name)));
+
+ return NS_OK;
+}
+
+static void txFnEndPI(txStylesheetCompilerState& aState) {
+ aState.addInstruction(popInstruction(aState));
+}
+
+/*
+ xsl:sort
+
+ (no instructions)
+*/
+static nsresult txFnStartSort(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix, txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ nsresult rv = NS_OK;
+
+ UniquePtr<Expr> select;
+ rv = getExprAttr(aAttributes, aAttrCount, nsGkAtoms::select, false, aState,
+ select);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (!select) {
+ UniquePtr<txNodeTest> nt(new txNodeTypeTest(txNodeTypeTest::NODE_TYPE));
+ select = MakeUnique<LocationStep>(nt.release(), LocationStep::SELF_AXIS);
+ }
+
+ UniquePtr<Expr> lang;
+ rv =
+ getAVTAttr(aAttributes, aAttrCount, nsGkAtoms::lang, false, aState, lang);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ UniquePtr<Expr> dataType;
+ rv = getAVTAttr(aAttributes, aAttrCount, nsGkAtoms::dataType, false, aState,
+ dataType);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ UniquePtr<Expr> order;
+ rv = getAVTAttr(aAttributes, aAttrCount, nsGkAtoms::order, false, aState,
+ order);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ UniquePtr<Expr> caseOrder;
+ rv = getAVTAttr(aAttributes, aAttrCount, nsGkAtoms::caseOrder, false, aState,
+ caseOrder);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aState.mSorter->addSort(std::move(select), std::move(lang),
+ std::move(dataType), std::move(order),
+ std::move(caseOrder));
+
+ aState.pushHandlerTable(gTxIgnoreHandler);
+
+ return NS_OK;
+}
+
+static void txFnEndSort(txStylesheetCompilerState& aState) {
+ aState.popHandlerTable();
+}
+
+/*
+ xsl:text
+
+ [children] (only txText)
+*/
+static nsresult txFnStartText(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix, txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ NS_ASSERTION(!aState.mDOE, "nested d-o-e elements should not happen");
+
+ nsresult rv = NS_OK;
+ txThreeState doe;
+ rv = getYesNoAttr(aAttributes, aAttrCount, nsGkAtoms::disableOutputEscaping,
+ false, aState, doe);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aState.mDOE = doe == eTrue;
+
+ aState.pushHandlerTable(gTxTextHandler);
+
+ return NS_OK;
+}
+
+static void txFnEndText(txStylesheetCompilerState& aState) {
+ aState.mDOE = false;
+ aState.popHandlerTable();
+}
+
+static nsresult txFnTextText(const nsAString& aStr,
+ txStylesheetCompilerState& aState) {
+ aState.addInstruction(MakeUnique<txText>(aStr, aState.mDOE));
+
+ return NS_OK;
+}
+
+/*
+ xsl:value-of
+
+ txValueOf
+*/
+static nsresult txFnStartValueOf(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix, txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ nsresult rv = NS_OK;
+
+ txThreeState doe;
+ rv = getYesNoAttr(aAttributes, aAttrCount, nsGkAtoms::disableOutputEscaping,
+ false, aState, doe);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ UniquePtr<Expr> select;
+ rv = getExprAttr(aAttributes, aAttrCount, nsGkAtoms::select, true, aState,
+ select);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aState.addInstruction(MakeUnique<txValueOf>(std::move(select), doe == eTrue));
+
+ aState.pushHandlerTable(gTxIgnoreHandler);
+
+ return NS_OK;
+}
+
+static void txFnEndValueOf(txStylesheetCompilerState& aState) {
+ aState.popHandlerTable();
+}
+
+/*
+ xsl:variable
+
+ txPushRTFHandler --- (for RTF-parameters)
+ [children] /
+ txSetVariable
+*/
+static nsresult txFnStartVariable(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix,
+ txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ nsresult rv = NS_OK;
+
+ txExpandedName name;
+ rv = getQNameAttr(aAttributes, aAttrCount, nsGkAtoms::name, true, aState,
+ name);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ UniquePtr<Expr> select;
+ rv = getExprAttr(aAttributes, aAttrCount, nsGkAtoms::select, false, aState,
+ select);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ UniquePtr<txSetVariable> var =
+ MakeUnique<txSetVariable>(name, std::move(select));
+ if (var->mValue) {
+ // XXX should be gTxErrorHandler?
+ aState.pushHandlerTable(gTxIgnoreHandler);
+ } else {
+ aState.pushHandlerTable(gTxVariableHandler);
+ }
+
+ pushInstruction(aState, std::move(var));
+
+ return NS_OK;
+}
+
+static void txFnEndVariable(txStylesheetCompilerState& aState) {
+ UniquePtr<txSetVariable> var = popInstruction<txSetVariable>(aState);
+
+ txHandlerTable* prev = aState.mHandlerTable;
+ aState.popHandlerTable();
+
+ if (prev == gTxVariableHandler) {
+ // No children were found.
+ NS_ASSERTION(!var->mValue, "There shouldn't be a select-expression here");
+ var->mValue = MakeUnique<txLiteralExpr>(u""_ns);
+ }
+
+ aState.addVariable(var->mName);
+
+ aState.addInstruction(std::move(var));
+}
+
+static nsresult txFnStartElementStartRTF(int32_t aNamespaceID,
+ nsAtom* aLocalName, nsAtom* aPrefix,
+ txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ aState.addInstruction(MakeUnique<txPushRTFHandler>());
+
+ aState.mHandlerTable = gTxTemplateHandler;
+
+ return NS_XSLT_GET_NEW_HANDLER;
+}
+
+static nsresult txFnTextStartRTF(const nsAString& aStr,
+ txStylesheetCompilerState& aState) {
+ TX_RETURN_IF_WHITESPACE(aStr, aState);
+
+ aState.addInstruction(MakeUnique<txPushRTFHandler>());
+
+ aState.mHandlerTable = gTxTemplateHandler;
+
+ return NS_XSLT_GET_NEW_HANDLER;
+}
+
+/*
+ xsl:when
+
+ (see xsl:choose)
+*/
+static nsresult txFnStartWhen(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix, txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ nsresult rv = NS_OK;
+
+ UniquePtr<Expr> test;
+ rv =
+ getExprAttr(aAttributes, aAttrCount, nsGkAtoms::test, true, aState, test);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aState.pushPtr(aState.addInstruction(
+ MakeUnique<txConditionalGoto>(std::move(test), nullptr)),
+ aState.eConditionalGoto);
+
+ aState.pushHandlerTable(gTxTemplateHandler);
+
+ return NS_OK;
+}
+
+static void txFnEndWhen(txStylesheetCompilerState& aState) {
+ aState.popHandlerTable();
+ aState.mChooseGotoList->add(
+ aState.addInstruction(MakeUnique<txGoTo>(nullptr)));
+
+ txConditionalGoto* condGoto =
+ static_cast<txConditionalGoto*>(aState.popPtr(aState.eConditionalGoto));
+ aState.addGotoTarget(&condGoto->mTarget);
+}
+
+/*
+ xsl:with-param
+
+ txPushRTFHandler -- for RTF-parameters
+ [children] /
+ txSetParam
+*/
+static nsresult txFnStartWithParam(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix,
+ txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ nsresult rv = NS_OK;
+
+ txExpandedName name;
+ rv = getQNameAttr(aAttributes, aAttrCount, nsGkAtoms::name, true, aState,
+ name);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ UniquePtr<Expr> select;
+ rv = getExprAttr(aAttributes, aAttrCount, nsGkAtoms::select, false, aState,
+ select);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ UniquePtr<txSetParam> var = MakeUnique<txSetParam>(name, std::move(select));
+ if (var->mValue) {
+ // XXX should be gTxErrorHandler?
+ aState.pushHandlerTable(gTxIgnoreHandler);
+ } else {
+ aState.pushHandlerTable(gTxVariableHandler);
+ }
+
+ pushInstruction(aState, std::move(var));
+
+ return NS_OK;
+}
+
+static void txFnEndWithParam(txStylesheetCompilerState& aState) {
+ UniquePtr<txSetParam> var = popInstruction<txSetParam>(aState);
+ txHandlerTable* prev = aState.mHandlerTable;
+ aState.popHandlerTable();
+
+ if (prev == gTxVariableHandler) {
+ // No children were found.
+ NS_ASSERTION(!var->mValue, "There shouldn't be a select-expression here");
+ var->mValue = MakeUnique<txLiteralExpr>(u""_ns);
+ }
+
+ aState.addInstruction(std::move(var));
+}
+
+/*
+ Unknown instruction
+
+ [fallbacks] if one or more xsl:fallbacks are found
+ or
+ txErrorInstruction otherwise
+*/
+static nsresult txFnStartUnknownInstruction(int32_t aNamespaceID,
+ nsAtom* aLocalName, nsAtom* aPrefix,
+ txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState) {
+ NS_ASSERTION(!aState.mSearchingForFallback,
+ "bad nesting of unknown-instruction and fallback handlers");
+
+ if (aNamespaceID == kNameSpaceID_XSLT && !aState.fcp()) {
+ return NS_ERROR_XSLT_PARSE_FAILURE;
+ }
+
+ aState.mSearchingForFallback = true;
+
+ aState.pushHandlerTable(gTxFallbackHandler);
+
+ return NS_OK;
+}
+
+static void txFnEndUnknownInstruction(txStylesheetCompilerState& aState) {
+ aState.popHandlerTable();
+
+ if (aState.mSearchingForFallback) {
+ aState.addInstruction(MakeUnique<txErrorInstruction>());
+ }
+
+ aState.mSearchingForFallback = false;
+}
+
+/**
+ * Table Datas
+ */
+
+struct txHandlerTableData {
+ txElementHandler mOtherHandler;
+ txElementHandler mLREHandler;
+ HandleTextFn mTextHandler;
+};
+
+const txHandlerTableData gTxIgnoreTableData = {
+ // Other
+ {0, 0, txFnStartElementIgnore, txFnEndElementIgnore},
+ // LRE
+ {0, 0, txFnStartElementIgnore, txFnEndElementIgnore},
+ // Text
+ txFnTextIgnore};
+
+const txElementHandler gTxRootElementHandlers[] = {
+ {kNameSpaceID_XSLT, "stylesheet", txFnStartStylesheet, txFnEndStylesheet},
+ {kNameSpaceID_XSLT, "transform", txFnStartStylesheet, txFnEndStylesheet}};
+
+const txHandlerTableData gTxRootTableData = {
+ // Other
+ {0, 0, txFnStartElementError, txFnEndElementError},
+ // LRE
+ {0, 0, txFnStartLREStylesheet, txFnEndLREStylesheet},
+ // Text
+ txFnTextError};
+
+const txHandlerTableData gTxEmbedTableData = {
+ // Other
+ {0, 0, txFnStartEmbed, txFnEndEmbed},
+ // LRE
+ {0, 0, txFnStartEmbed, txFnEndEmbed},
+ // Text
+ txFnTextIgnore};
+
+const txElementHandler gTxTopElementHandlers[] = {
+ {kNameSpaceID_XSLT, "attribute-set", txFnStartAttributeSet,
+ txFnEndAttributeSet},
+ {kNameSpaceID_XSLT, "decimal-format", txFnStartDecimalFormat,
+ txFnEndDecimalFormat},
+ {kNameSpaceID_XSLT, "include", txFnStartInclude, txFnEndInclude},
+ {kNameSpaceID_XSLT, "key", txFnStartKey, txFnEndKey},
+ {kNameSpaceID_XSLT, "namespace-alias", txFnStartNamespaceAlias,
+ txFnEndNamespaceAlias},
+ {kNameSpaceID_XSLT, "output", txFnStartOutput, txFnEndOutput},
+ {kNameSpaceID_XSLT, "param", txFnStartTopVariable, txFnEndTopVariable},
+ {kNameSpaceID_XSLT, "preserve-space", txFnStartStripSpace,
+ txFnEndStripSpace},
+ {kNameSpaceID_XSLT, "strip-space", txFnStartStripSpace, txFnEndStripSpace},
+ {kNameSpaceID_XSLT, "template", txFnStartTemplate, txFnEndTemplate},
+ {kNameSpaceID_XSLT, "variable", txFnStartTopVariable, txFnEndTopVariable}};
+
+const txHandlerTableData gTxTopTableData = {
+ // Other
+ {0, 0, txFnStartOtherTop, txFnEndOtherTop},
+ // LRE
+ {0, 0, txFnStartOtherTop, txFnEndOtherTop},
+ // Text
+ txFnTextIgnore};
+
+const txElementHandler gTxTemplateElementHandlers[] = {
+ {kNameSpaceID_XSLT, "apply-imports", txFnStartApplyImports,
+ txFnEndApplyImports},
+ {kNameSpaceID_XSLT, "apply-templates", txFnStartApplyTemplates,
+ txFnEndApplyTemplates},
+ {kNameSpaceID_XSLT, "attribute", txFnStartAttribute, txFnEndAttribute},
+ {kNameSpaceID_XSLT, "call-template", txFnStartCallTemplate,
+ txFnEndCallTemplate},
+ {kNameSpaceID_XSLT, "choose", txFnStartChoose, txFnEndChoose},
+ {kNameSpaceID_XSLT, "comment", txFnStartComment, txFnEndComment},
+ {kNameSpaceID_XSLT, "copy", txFnStartCopy, txFnEndCopy},
+ {kNameSpaceID_XSLT, "copy-of", txFnStartCopyOf, txFnEndCopyOf},
+ {kNameSpaceID_XSLT, "element", txFnStartElement, txFnEndElement},
+ {kNameSpaceID_XSLT, "fallback", txFnStartElementSetIgnore,
+ txFnEndElementSetIgnore},
+ {kNameSpaceID_XSLT, "for-each", txFnStartForEach, txFnEndForEach},
+ {kNameSpaceID_XSLT, "if", txFnStartIf, txFnEndIf},
+ {kNameSpaceID_XSLT, "message", txFnStartMessage, txFnEndMessage},
+ {kNameSpaceID_XSLT, "number", txFnStartNumber, txFnEndNumber},
+ {kNameSpaceID_XSLT, "processing-instruction", txFnStartPI, txFnEndPI},
+ {kNameSpaceID_XSLT, "text", txFnStartText, txFnEndText},
+ {kNameSpaceID_XSLT, "value-of", txFnStartValueOf, txFnEndValueOf},
+ {kNameSpaceID_XSLT, "variable", txFnStartVariable, txFnEndVariable}};
+
+const txHandlerTableData gTxTemplateTableData = {
+ // Other
+ {0, 0, txFnStartUnknownInstruction, txFnEndUnknownInstruction},
+ // LRE
+ {0, 0, txFnStartLRE, txFnEndLRE},
+ // Text
+ txFnText};
+
+const txHandlerTableData gTxTextTableData = {
+ // Other
+ {0, 0, txFnStartElementError, txFnEndElementError},
+ // LRE
+ {0, 0, txFnStartElementError, txFnEndElementError},
+ // Text
+ txFnTextText};
+
+const txElementHandler gTxApplyTemplatesElementHandlers[] = {
+ {kNameSpaceID_XSLT, "sort", txFnStartSort, txFnEndSort},
+ {kNameSpaceID_XSLT, "with-param", txFnStartWithParam, txFnEndWithParam}};
+
+const txHandlerTableData gTxApplyTemplatesTableData = {
+ // Other
+ {0, 0, txFnStartElementSetIgnore,
+ txFnEndElementSetIgnore}, // should this be error?
+ // LRE
+ {0, 0, txFnStartElementSetIgnore, txFnEndElementSetIgnore},
+ // Text
+ txFnTextIgnore};
+
+const txElementHandler gTxCallTemplateElementHandlers[] = {
+ {kNameSpaceID_XSLT, "with-param", txFnStartWithParam, txFnEndWithParam}};
+
+const txHandlerTableData gTxCallTemplateTableData = {
+ // Other
+ {0, 0, txFnStartElementSetIgnore,
+ txFnEndElementSetIgnore}, // should this be error?
+ // LRE
+ {0, 0, txFnStartElementSetIgnore, txFnEndElementSetIgnore},
+ // Text
+ txFnTextIgnore};
+
+const txHandlerTableData gTxVariableTableData = {
+ // Other
+ {0, 0, txFnStartElementStartRTF, 0},
+ // LRE
+ {0, 0, txFnStartElementStartRTF, 0},
+ // Text
+ txFnTextStartRTF};
+
+const txElementHandler gTxForEachElementHandlers[] = {
+ {kNameSpaceID_XSLT, "sort", txFnStartSort, txFnEndSort}};
+
+const txHandlerTableData gTxForEachTableData = {
+ // Other
+ {0, 0, txFnStartElementContinueTemplate, 0},
+ // LRE
+ {0, 0, txFnStartElementContinueTemplate, 0},
+ // Text
+ txFnTextContinueTemplate};
+
+const txHandlerTableData gTxTopVariableTableData = {
+ // Other
+ {0, 0, txFnStartElementStartTopVar, 0},
+ // LRE
+ {0, 0, txFnStartElementStartTopVar, 0},
+ // Text
+ txFnTextStartTopVar};
+
+const txElementHandler gTxChooseElementHandlers[] = {
+ {kNameSpaceID_XSLT, "otherwise", txFnStartOtherwise, txFnEndOtherwise},
+ {kNameSpaceID_XSLT, "when", txFnStartWhen, txFnEndWhen}};
+
+const txHandlerTableData gTxChooseTableData = {
+ // Other
+ {0, 0, txFnStartElementError, 0},
+ // LRE
+ {0, 0, txFnStartElementError, 0},
+ // Text
+ txFnTextError};
+
+const txElementHandler gTxParamElementHandlers[] = {
+ {kNameSpaceID_XSLT, "param", txFnStartParam, txFnEndParam}};
+
+const txHandlerTableData gTxParamTableData = {
+ // Other
+ {0, 0, txFnStartElementContinueTemplate, 0},
+ // LRE
+ {0, 0, txFnStartElementContinueTemplate, 0},
+ // Text
+ txFnTextContinueTemplate};
+
+const txElementHandler gTxImportElementHandlers[] = {
+ {kNameSpaceID_XSLT, "import", txFnStartImport, txFnEndImport}};
+
+const txHandlerTableData gTxImportTableData = {
+ // Other
+ {0, 0, txFnStartElementContinueTopLevel, 0},
+ // LRE
+ {0, 0, txFnStartOtherTop, txFnEndOtherTop}, // XXX what should we do here?
+ // Text
+ txFnTextIgnore // XXX what should we do here?
+};
+
+const txElementHandler gTxAttributeSetElementHandlers[] = {
+ {kNameSpaceID_XSLT, "attribute", txFnStartAttribute, txFnEndAttribute}};
+
+const txHandlerTableData gTxAttributeSetTableData = {
+ // Other
+ {0, 0, txFnStartElementError, 0},
+ // LRE
+ {0, 0, txFnStartElementError, 0},
+ // Text
+ txFnTextError};
+
+const txElementHandler gTxFallbackElementHandlers[] = {
+ {kNameSpaceID_XSLT, "fallback", txFnStartFallback, txFnEndFallback}};
+
+const txHandlerTableData gTxFallbackTableData = {
+ // Other
+ {0, 0, txFnStartElementSetIgnore, txFnEndElementSetIgnore},
+ // LRE
+ {0, 0, txFnStartElementSetIgnore, txFnEndElementSetIgnore},
+ // Text
+ txFnTextIgnore};
+
+/**
+ * txHandlerTable
+ */
+txHandlerTable::txHandlerTable(const HandleTextFn aTextHandler,
+ const txElementHandler* aLREHandler,
+ const txElementHandler* aOtherHandler)
+ : mTextHandler(aTextHandler),
+ mLREHandler(aLREHandler),
+ mOtherHandler(aOtherHandler) {}
+
+nsresult txHandlerTable::init(const txElementHandler* aHandlers,
+ uint32_t aCount) {
+ nsresult rv = NS_OK;
+
+ uint32_t i;
+ for (i = 0; i < aCount; ++i) {
+ RefPtr<nsAtom> nameAtom = NS_Atomize(aHandlers->mLocalName);
+ txExpandedName name(aHandlers->mNamespaceID, nameAtom);
+ rv = mHandlers.add(name, aHandlers);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ ++aHandlers;
+ }
+ return NS_OK;
+}
+
+const txElementHandler* txHandlerTable::find(int32_t aNamespaceID,
+ nsAtom* aLocalName) {
+ txExpandedName name(aNamespaceID, aLocalName);
+ const txElementHandler* handler = mHandlers.get(name);
+ if (!handler) {
+ handler = mOtherHandler;
+ }
+ return handler;
+}
+
+#define INIT_HANDLER(_name) \
+ gTx##_name##Handler = new txHandlerTable( \
+ gTx##_name##TableData.mTextHandler, &gTx##_name##TableData.mLREHandler, \
+ &gTx##_name##TableData.mOtherHandler); \
+ if (!gTx##_name##Handler) return false
+
+#define INIT_HANDLER_WITH_ELEMENT_HANDLERS(_name) \
+ INIT_HANDLER(_name); \
+ \
+ rv = gTx##_name##Handler->init(gTx##_name##ElementHandlers, \
+ ArrayLength(gTx##_name##ElementHandlers)); \
+ if (NS_FAILED(rv)) return false
+
+#define SHUTDOWN_HANDLER(_name) \
+ delete gTx##_name##Handler; \
+ gTx##_name##Handler = nullptr
+
+// static
+bool txHandlerTable::init() {
+ nsresult rv = NS_OK;
+
+ INIT_HANDLER_WITH_ELEMENT_HANDLERS(Root);
+ INIT_HANDLER(Embed);
+ INIT_HANDLER_WITH_ELEMENT_HANDLERS(Top);
+ INIT_HANDLER(Ignore);
+ INIT_HANDLER_WITH_ELEMENT_HANDLERS(Template);
+ INIT_HANDLER(Text);
+ INIT_HANDLER_WITH_ELEMENT_HANDLERS(ApplyTemplates);
+ INIT_HANDLER_WITH_ELEMENT_HANDLERS(CallTemplate);
+ INIT_HANDLER(Variable);
+ INIT_HANDLER_WITH_ELEMENT_HANDLERS(ForEach);
+ INIT_HANDLER(TopVariable);
+ INIT_HANDLER_WITH_ELEMENT_HANDLERS(Choose);
+ INIT_HANDLER_WITH_ELEMENT_HANDLERS(Param);
+ INIT_HANDLER_WITH_ELEMENT_HANDLERS(Import);
+ INIT_HANDLER_WITH_ELEMENT_HANDLERS(AttributeSet);
+ INIT_HANDLER_WITH_ELEMENT_HANDLERS(Fallback);
+
+ return true;
+}
+
+// static
+void txHandlerTable::shutdown() {
+ SHUTDOWN_HANDLER(Root);
+ SHUTDOWN_HANDLER(Embed);
+ SHUTDOWN_HANDLER(Top);
+ SHUTDOWN_HANDLER(Ignore);
+ SHUTDOWN_HANDLER(Template);
+ SHUTDOWN_HANDLER(Text);
+ SHUTDOWN_HANDLER(ApplyTemplates);
+ SHUTDOWN_HANDLER(CallTemplate);
+ SHUTDOWN_HANDLER(Variable);
+ SHUTDOWN_HANDLER(ForEach);
+ SHUTDOWN_HANDLER(TopVariable);
+ SHUTDOWN_HANDLER(Choose);
+ SHUTDOWN_HANDLER(Param);
+ SHUTDOWN_HANDLER(Import);
+ SHUTDOWN_HANDLER(AttributeSet);
+ SHUTDOWN_HANDLER(Fallback);
+}
diff --git a/dom/xslt/xslt/txStylesheetCompileHandlers.h b/dom/xslt/xslt/txStylesheetCompileHandlers.h
new file mode 100644
index 0000000000..a1913110ef
--- /dev/null
+++ b/dom/xslt/xslt/txStylesheetCompileHandlers.h
@@ -0,0 +1,54 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef TRANSFRMX_TXSTYLESHEETCOMPILEHANDLERS_H
+#define TRANSFRMX_TXSTYLESHEETCOMPILEHANDLERS_H
+
+#include "nsError.h"
+#include "txNamespaceMap.h"
+#include "txExpandedNameMap.h"
+
+struct txStylesheetAttr;
+class txStylesheetCompilerState;
+
+using HandleStartFn = nsresult (*)(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix,
+ txStylesheetAttr* aAttributes,
+ int32_t aAttrCount,
+ txStylesheetCompilerState& aState);
+using HandleEndFn = void (*)(txStylesheetCompilerState& aState);
+using HandleTextFn = nsresult (*)(const nsAString& aStr,
+ txStylesheetCompilerState& aState);
+
+struct txElementHandler {
+ int32_t mNamespaceID;
+ const char* mLocalName;
+ HandleStartFn mStartFunction;
+ HandleEndFn mEndFunction;
+};
+
+class txHandlerTable {
+ public:
+ txHandlerTable(const HandleTextFn aTextHandler,
+ const txElementHandler* aLREHandler,
+ const txElementHandler* aOtherHandler);
+ nsresult init(const txElementHandler* aHandlers, uint32_t aCount);
+ const txElementHandler* find(int32_t aNamespaceID, nsAtom* aLocalName);
+
+ const HandleTextFn mTextHandler;
+ const txElementHandler* const mLREHandler;
+
+ static bool init();
+ static void shutdown();
+
+ private:
+ const txElementHandler* const mOtherHandler;
+ txExpandedNameMap<const txElementHandler> mHandlers;
+};
+
+extern txHandlerTable* gTxRootHandler;
+extern txHandlerTable* gTxEmbedHandler;
+
+#endif // TRANSFRMX_TXSTYLESHEETCOMPILEHANDLERS_H
diff --git a/dom/xslt/xslt/txStylesheetCompiler.cpp b/dom/xslt/xslt/txStylesheetCompiler.cpp
new file mode 100644
index 0000000000..82b6de4c79
--- /dev/null
+++ b/dom/xslt/xslt/txStylesheetCompiler.cpp
@@ -0,0 +1,839 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txStylesheetCompiler.h"
+
+#include <utility>
+
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/UniquePtrExtensions.h"
+#include "nsGkAtoms.h"
+#include "nsServiceManagerUtils.h"
+#include "nsTArray.h"
+#include "nsWhitespaceTokenizer.h"
+#include "txExprParser.h"
+#include "txInstructions.h"
+#include "txLog.h"
+#include "txPatternParser.h"
+#include "txStringUtils.h"
+#include "txStylesheet.h"
+#include "txStylesheetCompileHandlers.h"
+#include "txToplevelItems.h"
+#include "txURIUtils.h"
+#include "txXSLTFunctions.h"
+
+using namespace mozilla;
+using mozilla::dom::ReferrerPolicy;
+
+txStylesheetCompiler::txStylesheetCompiler(const nsAString& aStylesheetURI,
+ ReferrerPolicy aReferrerPolicy,
+ txACompileObserver* aObserver)
+ : txStylesheetCompilerState(aObserver) {
+ mStatus = init(aStylesheetURI, aReferrerPolicy, nullptr, nullptr);
+}
+
+txStylesheetCompiler::txStylesheetCompiler(const nsAString& aStylesheetURI,
+ txStylesheet* aStylesheet,
+ txListIterator* aInsertPosition,
+ ReferrerPolicy aReferrerPolicy,
+ txACompileObserver* aObserver)
+ : txStylesheetCompilerState(aObserver) {
+ mStatus = init(aStylesheetURI, aReferrerPolicy, aStylesheet, aInsertPosition);
+}
+
+void txStylesheetCompiler::setBaseURI(const nsString& aBaseURI) {
+ NS_ASSERTION(mObjectStack.size() == 1 && !mObjectStack.peek(),
+ "Execution already started");
+
+ if (NS_FAILED(mStatus)) {
+ return;
+ }
+
+ mElementContext->mBaseURI = aBaseURI;
+}
+
+nsresult txStylesheetCompiler::startElement(int32_t aNamespaceID,
+ nsAtom* aLocalName, nsAtom* aPrefix,
+ txStylesheetAttr* aAttributes,
+ int32_t aAttrCount) {
+ if (NS_FAILED(mStatus)) {
+ // ignore content after failure
+ // XXX reevaluate once expat stops on failure
+ return NS_OK;
+ }
+
+ nsresult rv = flushCharacters();
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // look for new namespace mappings
+ bool hasOwnNamespaceMap = false;
+ int32_t i;
+ for (i = 0; i < aAttrCount; ++i) {
+ txStylesheetAttr* attr = aAttributes + i;
+ if (attr->mNamespaceID == kNameSpaceID_XMLNS) {
+ rv = ensureNewElementContext();
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (!hasOwnNamespaceMap) {
+ mElementContext->mMappings =
+ new txNamespaceMap(*mElementContext->mMappings);
+ hasOwnNamespaceMap = true;
+ }
+
+ if (attr->mLocalName == nsGkAtoms::xmlns) {
+ mElementContext->mMappings->mapNamespace(nullptr, attr->mValue);
+ } else {
+ mElementContext->mMappings->mapNamespace(attr->mLocalName,
+ attr->mValue);
+ }
+ }
+ }
+
+ return startElementInternal(aNamespaceID, aLocalName, aPrefix, aAttributes,
+ aAttrCount);
+}
+
+nsresult txStylesheetCompiler::startElement(const char16_t* aName,
+ const char16_t** aAttrs,
+ int32_t aAttrCount) {
+ if (NS_FAILED(mStatus)) {
+ // ignore content after failure
+ // XXX reevaluate once expat stops on failure
+ return NS_OK;
+ }
+
+ nsresult rv = flushCharacters();
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ UniquePtr<txStylesheetAttr[]> atts;
+ if (aAttrCount > 0) {
+ atts = MakeUnique<txStylesheetAttr[]>(aAttrCount);
+ }
+
+ bool hasOwnNamespaceMap = false;
+ int32_t i;
+ for (i = 0; i < aAttrCount; ++i) {
+ rv = XMLUtils::splitExpatName(
+ aAttrs[i * 2], getter_AddRefs(atts[i].mPrefix),
+ getter_AddRefs(atts[i].mLocalName), &atts[i].mNamespaceID);
+ NS_ENSURE_SUCCESS(rv, rv);
+ atts[i].mValue.Append(aAttrs[i * 2 + 1]);
+
+ RefPtr<nsAtom> prefixToBind;
+ if (atts[i].mPrefix == nsGkAtoms::xmlns) {
+ prefixToBind = atts[i].mLocalName;
+ } else if (atts[i].mNamespaceID == kNameSpaceID_XMLNS) {
+ prefixToBind = nsGkAtoms::_empty;
+ }
+
+ if (prefixToBind) {
+ rv = ensureNewElementContext();
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (!hasOwnNamespaceMap) {
+ mElementContext->mMappings =
+ new txNamespaceMap(*mElementContext->mMappings);
+ hasOwnNamespaceMap = true;
+ }
+
+ rv = mElementContext->mMappings->mapNamespace(prefixToBind,
+ atts[i].mValue);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ }
+
+ RefPtr<nsAtom> prefix, localname;
+ int32_t namespaceID;
+ rv = XMLUtils::splitExpatName(aName, getter_AddRefs(prefix),
+ getter_AddRefs(localname), &namespaceID);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ return startElementInternal(namespaceID, localname, prefix, atts.get(),
+ aAttrCount);
+}
+
+nsresult txStylesheetCompiler::startElementInternal(
+ int32_t aNamespaceID, nsAtom* aLocalName, nsAtom* aPrefix,
+ txStylesheetAttr* aAttributes, int32_t aAttrCount) {
+ nsresult rv = NS_OK;
+ int32_t i;
+ for (i = mInScopeVariables.Length() - 1; i >= 0; --i) {
+ ++mInScopeVariables[i].mLevel;
+ }
+
+ // Update the elementcontext if we have special attributes
+ for (i = 0; i < aAttrCount; ++i) {
+ txStylesheetAttr* attr = aAttributes + i;
+
+ // id
+ if (mEmbedStatus == eNeedEmbed && attr->mLocalName == nsGkAtoms::id &&
+ attr->mNamespaceID == kNameSpaceID_None &&
+ attr->mValue.Equals(mTarget)) {
+ // We found the right ID, signal to compile the
+ // embedded stylesheet.
+ mEmbedStatus = eInEmbed;
+ }
+
+ // xml:space
+ if (attr->mNamespaceID == kNameSpaceID_XML &&
+ attr->mLocalName == nsGkAtoms::space) {
+ rv = ensureNewElementContext();
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (TX_StringEqualsAtom(attr->mValue, nsGkAtoms::preserve)) {
+ mElementContext->mPreserveWhitespace = true;
+ } else if (TX_StringEqualsAtom(attr->mValue, nsGkAtoms::_default)) {
+ mElementContext->mPreserveWhitespace = false;
+ } else {
+ return NS_ERROR_XSLT_PARSE_FAILURE;
+ }
+ }
+
+ // extension-element-prefixes
+ if ((attr->mNamespaceID == kNameSpaceID_XSLT &&
+ attr->mLocalName == nsGkAtoms::extensionElementPrefixes &&
+ aNamespaceID != kNameSpaceID_XSLT) ||
+ (attr->mNamespaceID == kNameSpaceID_None &&
+ attr->mLocalName == nsGkAtoms::extensionElementPrefixes &&
+ aNamespaceID == kNameSpaceID_XSLT &&
+ (aLocalName == nsGkAtoms::stylesheet ||
+ aLocalName == nsGkAtoms::transform))) {
+ rv = ensureNewElementContext();
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ nsWhitespaceTokenizer tok(attr->mValue);
+ while (tok.hasMoreTokens()) {
+ int32_t namespaceID =
+ mElementContext->mMappings->lookupNamespaceWithDefault(
+ tok.nextToken());
+
+ if (namespaceID == kNameSpaceID_Unknown)
+ return NS_ERROR_XSLT_PARSE_FAILURE;
+
+ mElementContext->mInstructionNamespaces.AppendElement(namespaceID);
+ }
+
+ attr->mLocalName = nullptr;
+ }
+
+ // version
+ if ((attr->mNamespaceID == kNameSpaceID_XSLT &&
+ attr->mLocalName == nsGkAtoms::version &&
+ aNamespaceID != kNameSpaceID_XSLT) ||
+ (attr->mNamespaceID == kNameSpaceID_None &&
+ attr->mLocalName == nsGkAtoms::version &&
+ aNamespaceID == kNameSpaceID_XSLT &&
+ (aLocalName == nsGkAtoms::stylesheet ||
+ aLocalName == nsGkAtoms::transform))) {
+ rv = ensureNewElementContext();
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (attr->mValue.EqualsLiteral("1.0")) {
+ mElementContext->mForwardsCompatibleParsing = false;
+ } else {
+ mElementContext->mForwardsCompatibleParsing = true;
+ }
+ }
+ }
+
+ // Find the right elementhandler and execute it
+ bool isInstruction = false;
+ int32_t count = mElementContext->mInstructionNamespaces.Length();
+ for (i = 0; i < count; ++i) {
+ if (mElementContext->mInstructionNamespaces[i] == aNamespaceID) {
+ isInstruction = true;
+ break;
+ }
+ }
+
+ const txElementHandler* handler;
+ do {
+ handler = isInstruction ? mHandlerTable->find(aNamespaceID, aLocalName)
+ : mHandlerTable->mLREHandler;
+
+ rv = (handler->mStartFunction)(aNamespaceID, aLocalName, aPrefix,
+ aAttributes, aAttrCount, *this);
+ } while (rv == NS_XSLT_GET_NEW_HANDLER);
+
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (!fcp()) {
+ for (i = 0; i < aAttrCount; ++i) {
+ txStylesheetAttr& attr = aAttributes[i];
+ if (attr.mLocalName && (attr.mNamespaceID == kNameSpaceID_XSLT ||
+ (aNamespaceID == kNameSpaceID_XSLT &&
+ attr.mNamespaceID == kNameSpaceID_None))) {
+ // XXX ErrorReport: unknown attribute
+ return NS_ERROR_XSLT_PARSE_FAILURE;
+ }
+ }
+ }
+
+ pushPtr(const_cast<txElementHandler*>(handler), eElementHandler);
+
+ mElementContext->mDepth++;
+
+ return NS_OK;
+}
+
+nsresult txStylesheetCompiler::endElement() {
+ if (NS_FAILED(mStatus)) {
+ // ignore content after failure
+ // XXX reevaluate once expat stops on failure
+ return NS_OK;
+ }
+
+ nsresult rv = flushCharacters();
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ int32_t i;
+ for (i = mInScopeVariables.Length() - 1; i >= 0; --i) {
+ txInScopeVariable& var = mInScopeVariables[i];
+ if (!--(var.mLevel)) {
+ addInstruction(MakeUnique<txRemoveVariable>(var.mName));
+
+ mInScopeVariables.RemoveElementAt(i);
+ }
+ }
+
+ const txElementHandler* handler = const_cast<const txElementHandler*>(
+ static_cast<txElementHandler*>(popPtr(eElementHandler)));
+ (handler->mEndFunction)(*this);
+
+ if (!--mElementContext->mDepth) {
+ // this will delete the old object
+ mElementContext = WrapUnique(static_cast<txElementContext*>(popObject()));
+ }
+
+ return NS_OK;
+}
+
+nsresult txStylesheetCompiler::characters(const nsAString& aStr) {
+ if (NS_FAILED(mStatus)) {
+ // ignore content after failure
+ // XXX reevaluate once expat stops on failure
+ return NS_OK;
+ }
+
+ mCharacters.Append(aStr);
+
+ return NS_OK;
+}
+
+nsresult txStylesheetCompiler::doneLoading() {
+ MOZ_LOG(txLog::xslt, LogLevel::Info,
+ ("Compiler::doneLoading: %s\n",
+ NS_LossyConvertUTF16toASCII(mStylesheetURI).get()));
+ if (NS_FAILED(mStatus)) {
+ return mStatus;
+ }
+
+ mDoneWithThisStylesheet = true;
+
+ return maybeDoneCompiling();
+}
+
+void txStylesheetCompiler::cancel(nsresult aError, const char16_t* aErrorText,
+ const char16_t* aParam) {
+ MOZ_LOG(txLog::xslt, LogLevel::Info,
+ ("Compiler::cancel: %s, module: %d, code %d\n",
+ NS_LossyConvertUTF16toASCII(mStylesheetURI).get(),
+ NS_ERROR_GET_MODULE(aError), NS_ERROR_GET_CODE(aError)));
+ if (NS_SUCCEEDED(mStatus)) {
+ mStatus = aError;
+ }
+
+ if (mObserver) {
+ mObserver->onDoneCompiling(this, mStatus, aErrorText, aParam);
+ // This will ensure that we don't call onDoneCompiling twice. Also
+ // ensures that we don't keep the observer alive longer then necessary.
+ mObserver = nullptr;
+ }
+}
+
+txStylesheet* txStylesheetCompiler::getStylesheet() { return mStylesheet; }
+
+nsresult txStylesheetCompiler::loadURI(const nsAString& aUri,
+ const nsAString& aReferrerUri,
+ ReferrerPolicy aReferrerPolicy,
+ txStylesheetCompiler* aCompiler) {
+ MOZ_LOG(txLog::xslt, LogLevel::Info,
+ ("Compiler::loadURI forwards %s thru %s\n",
+ NS_LossyConvertUTF16toASCII(aUri).get(),
+ NS_LossyConvertUTF16toASCII(mStylesheetURI).get()));
+ if (mStylesheetURI.Equals(aUri)) {
+ return NS_ERROR_XSLT_LOAD_RECURSION;
+ }
+ return mObserver ? mObserver->loadURI(aUri, aReferrerUri, aReferrerPolicy,
+ aCompiler)
+ : NS_ERROR_FAILURE;
+}
+
+void txStylesheetCompiler::onDoneCompiling(txStylesheetCompiler* aCompiler,
+ nsresult aResult,
+ const char16_t* aErrorText,
+ const char16_t* aParam) {
+ if (NS_FAILED(aResult)) {
+ cancel(aResult, aErrorText, aParam);
+ return;
+ }
+
+ mChildCompilerList.RemoveElement(aCompiler);
+
+ maybeDoneCompiling();
+}
+
+nsresult txStylesheetCompiler::flushCharacters() {
+ // Bail if we don't have any characters. The handler will detect
+ // ignoreable whitespace
+ if (mCharacters.IsEmpty()) {
+ return NS_OK;
+ }
+
+ nsresult rv = NS_OK;
+
+ do {
+ rv = (mHandlerTable->mTextHandler)(mCharacters, *this);
+ } while (rv == NS_XSLT_GET_NEW_HANDLER);
+
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ mCharacters.Truncate();
+
+ return NS_OK;
+}
+
+nsresult txStylesheetCompiler::ensureNewElementContext() {
+ // Do we already have a new context?
+ if (!mElementContext->mDepth) {
+ return NS_OK;
+ }
+
+ UniquePtr<txElementContext> context(new txElementContext(*mElementContext));
+ pushObject(mElementContext.release());
+ mElementContext = std::move(context);
+
+ return NS_OK;
+}
+
+nsresult txStylesheetCompiler::maybeDoneCompiling() {
+ if (!mDoneWithThisStylesheet || !mChildCompilerList.IsEmpty()) {
+ return NS_OK;
+ }
+
+ if (mIsTopCompiler) {
+ nsresult rv = mStylesheet->doneCompiling();
+ if (NS_FAILED(rv)) {
+ cancel(rv);
+ return rv;
+ }
+ }
+
+ if (mObserver) {
+ mObserver->onDoneCompiling(this, mStatus);
+ // This will ensure that we don't call onDoneCompiling twice. Also
+ // ensures that we don't keep the observer alive longer then necessary.
+ mObserver = nullptr;
+ }
+
+ return NS_OK;
+}
+
+/**
+ * txStylesheetCompilerState
+ */
+
+txStylesheetCompilerState::txStylesheetCompilerState(
+ txACompileObserver* aObserver)
+ : mHandlerTable(nullptr),
+ mSorter(nullptr),
+ mDOE(false),
+ mSearchingForFallback(false),
+ mDisAllowed(0),
+ mObserver(aObserver),
+ mEmbedStatus(eNoEmbed),
+ mIsTopCompiler(false),
+ mDoneWithThisStylesheet(false),
+ mNextInstrPtr(nullptr),
+ mToplevelIterator(nullptr),
+ mReferrerPolicy(ReferrerPolicy::_empty) {
+ // Embedded stylesheets have another handler, which is set in
+ // txStylesheetCompiler::init if the baseURI has a fragment identifier.
+ mHandlerTable = gTxRootHandler;
+}
+
+nsresult txStylesheetCompilerState::init(const nsAString& aStylesheetURI,
+ ReferrerPolicy aReferrerPolicy,
+ txStylesheet* aStylesheet,
+ txListIterator* aInsertPosition) {
+ NS_ASSERTION(!aStylesheet || aInsertPosition,
+ "must provide insertposition if loading subsheet");
+ mStylesheetURI = aStylesheetURI;
+ mReferrerPolicy = aReferrerPolicy;
+ // Check for fragment identifier of an embedded stylesheet.
+ int32_t fragment = aStylesheetURI.FindChar('#') + 1;
+ if (fragment > 0) {
+ int32_t fragmentLength = aStylesheetURI.Length() - fragment;
+ if (fragmentLength > 0) {
+ // This is really an embedded stylesheet, not just a
+ // "url#". We may want to unescape the fragment.
+ mTarget = Substring(aStylesheetURI, (uint32_t)fragment, fragmentLength);
+ mEmbedStatus = eNeedEmbed;
+ mHandlerTable = gTxEmbedHandler;
+ }
+ }
+ nsresult rv = NS_OK;
+ if (aStylesheet) {
+ mStylesheet = aStylesheet;
+ mToplevelIterator = *aInsertPosition;
+ mIsTopCompiler = false;
+ } else {
+ mStylesheet = new txStylesheet;
+ rv = mStylesheet->init();
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ mToplevelIterator =
+ txListIterator(&mStylesheet->mRootFrame->mToplevelItems);
+ mToplevelIterator.next(); // go to the end of the list
+ mIsTopCompiler = true;
+ }
+
+ mElementContext = MakeUnique<txElementContext>(aStylesheetURI);
+
+ // Push the "old" txElementContext
+ pushObject(nullptr);
+
+ return NS_OK;
+}
+
+txStylesheetCompilerState::~txStylesheetCompilerState() {
+ while (!mObjectStack.isEmpty()) {
+ delete popObject();
+ }
+}
+
+void txStylesheetCompilerState::pushHandlerTable(txHandlerTable* aTable) {
+ pushPtr(mHandlerTable, eHandlerTable);
+ mHandlerTable = aTable;
+}
+
+void txStylesheetCompilerState::popHandlerTable() {
+ mHandlerTable = static_cast<txHandlerTable*>(popPtr(eHandlerTable));
+}
+
+void txStylesheetCompilerState::pushSorter(txPushNewContext* aSorter) {
+ pushPtr(mSorter, ePushNewContext);
+ mSorter = aSorter;
+}
+
+void txStylesheetCompilerState::popSorter() {
+ mSorter = static_cast<txPushNewContext*>(popPtr(ePushNewContext));
+}
+
+void txStylesheetCompilerState::pushChooseGotoList() {
+ pushObject(mChooseGotoList.release());
+ mChooseGotoList = MakeUnique<txList>();
+}
+
+void txStylesheetCompilerState::popChooseGotoList() {
+ // this will delete the old value
+ mChooseGotoList = WrapUnique(static_cast<txList*>(popObject()));
+}
+
+void txStylesheetCompilerState::pushObject(txObject* aObject) {
+ mObjectStack.push(aObject);
+}
+
+txObject* txStylesheetCompilerState::popObject() {
+ return static_cast<txObject*>(mObjectStack.pop());
+}
+
+void txStylesheetCompilerState::pushPtr(void* aPtr, enumStackType aType) {
+#ifdef TX_DEBUG_STACK
+ MOZ_LOG(txLog::xslt, LogLevel::Debug,
+ ("pushPtr: 0x%x type %u\n", aPtr, aType));
+#endif
+ mTypeStack.AppendElement(aType);
+ mOtherStack.push(aPtr);
+}
+
+void* txStylesheetCompilerState::popPtr(enumStackType aType) {
+ if (mTypeStack.IsEmpty()) {
+ MOZ_CRASH("Attempt to pop when type stack is empty");
+ }
+
+ enumStackType type = mTypeStack.PopLastElement();
+ void* value = mOtherStack.pop();
+
+#ifdef TX_DEBUG_STACK
+ MOZ_LOG(txLog::xslt, LogLevel::Debug,
+ ("popPtr: 0x%x type %u requested %u\n", value, type, aType));
+#endif
+
+ if (type != aType) {
+ MOZ_CRASH("Expected type does not match top element type");
+ }
+
+ return value;
+}
+
+void txStylesheetCompilerState::addToplevelItem(txToplevelItem* aItem) {
+ mToplevelIterator.addBefore(aItem);
+}
+
+nsresult txStylesheetCompilerState::openInstructionContainer(
+ txInstructionContainer* aContainer) {
+ MOZ_ASSERT(!mNextInstrPtr, "can't nest instruction-containers");
+
+ mNextInstrPtr = &aContainer->mFirstInstruction;
+ return NS_OK;
+}
+
+void txStylesheetCompilerState::closeInstructionContainer() {
+ NS_ASSERTION(mGotoTargetPointers.IsEmpty(),
+ "GotoTargets still exists, did you forget to add txReturn?");
+ mNextInstrPtr = 0;
+}
+
+txInstruction* txStylesheetCompilerState::addInstruction(
+ UniquePtr<txInstruction>&& aInstruction) {
+ MOZ_ASSERT(mNextInstrPtr, "adding instruction outside container");
+
+ txInstruction* newInstr = aInstruction.get();
+
+ *mNextInstrPtr = std::move(aInstruction);
+ mNextInstrPtr = &newInstr->mNext;
+
+ uint32_t i, count = mGotoTargetPointers.Length();
+ for (i = 0; i < count; ++i) {
+ *mGotoTargetPointers[i] = newInstr;
+ }
+ mGotoTargetPointers.Clear();
+
+ return newInstr;
+}
+
+nsresult txStylesheetCompilerState::loadIncludedStylesheet(
+ const nsAString& aURI) {
+ MOZ_LOG(txLog::xslt, LogLevel::Info,
+ ("CompilerState::loadIncludedStylesheet: %s\n",
+ NS_LossyConvertUTF16toASCII(aURI).get()));
+ if (mStylesheetURI.Equals(aURI)) {
+ return NS_ERROR_XSLT_LOAD_RECURSION;
+ }
+ NS_ENSURE_TRUE(mObserver, NS_ERROR_NOT_IMPLEMENTED);
+
+ UniquePtr<txToplevelItem> item(new txDummyItem);
+
+ mToplevelIterator.addBefore(item.release());
+
+ // step back to the dummy-item
+ mToplevelIterator.previous();
+
+ txACompileObserver* observer = static_cast<txStylesheetCompiler*>(this);
+
+ RefPtr<txStylesheetCompiler> compiler = new txStylesheetCompiler(
+ aURI, mStylesheet, &mToplevelIterator, mReferrerPolicy, observer);
+
+ // step forward before calling the observer in case of syncronous loading
+ mToplevelIterator.next();
+
+ mChildCompilerList.AppendElement(compiler);
+
+ nsresult rv =
+ mObserver->loadURI(aURI, mStylesheetURI, mReferrerPolicy, compiler);
+ if (NS_FAILED(rv)) {
+ mChildCompilerList.RemoveElement(compiler);
+ }
+
+ return rv;
+}
+
+nsresult txStylesheetCompilerState::loadImportedStylesheet(
+ const nsAString& aURI, txStylesheet::ImportFrame* aFrame) {
+ MOZ_LOG(txLog::xslt, LogLevel::Info,
+ ("CompilerState::loadImportedStylesheet: %s\n",
+ NS_LossyConvertUTF16toASCII(aURI).get()));
+ if (mStylesheetURI.Equals(aURI)) {
+ return NS_ERROR_XSLT_LOAD_RECURSION;
+ }
+ NS_ENSURE_TRUE(mObserver, NS_ERROR_NOT_IMPLEMENTED);
+
+ txListIterator iter(&aFrame->mToplevelItems);
+ iter.next(); // go to the end of the list
+
+ txACompileObserver* observer = static_cast<txStylesheetCompiler*>(this);
+
+ RefPtr<txStylesheetCompiler> compiler = new txStylesheetCompiler(
+ aURI, mStylesheet, &iter, mReferrerPolicy, observer);
+
+ mChildCompilerList.AppendElement(compiler);
+
+ nsresult rv =
+ mObserver->loadURI(aURI, mStylesheetURI, mReferrerPolicy, compiler);
+ if (NS_FAILED(rv)) {
+ mChildCompilerList.RemoveElement(compiler);
+ }
+
+ return rv;
+}
+
+void txStylesheetCompilerState::addGotoTarget(txInstruction** aTargetPointer) {
+ mGotoTargetPointers.AppendElement(aTargetPointer);
+}
+
+void txStylesheetCompilerState::addVariable(const txExpandedName& aName) {
+ mInScopeVariables.AppendElement(aName);
+}
+
+nsresult txStylesheetCompilerState::resolveNamespacePrefix(nsAtom* aPrefix,
+ int32_t& aID) {
+ NS_ASSERTION(aPrefix && aPrefix != nsGkAtoms::_empty,
+ "caller should handle default namespace ''");
+ aID = mElementContext->mMappings->lookupNamespace(aPrefix);
+ return (aID != kNameSpaceID_Unknown) ? NS_OK : NS_ERROR_FAILURE;
+}
+
+/**
+ * Error Function to be used for unknown extension functions.
+ *
+ */
+class txErrorFunctionCall : public FunctionCall {
+ public:
+ explicit txErrorFunctionCall(nsAtom* aName) : mName(aName) {}
+
+ TX_DECL_FUNCTION
+
+ private:
+ RefPtr<nsAtom> mName;
+};
+
+nsresult txErrorFunctionCall::evaluate(txIEvalContext* aContext,
+ txAExprResult** aResult) {
+ *aResult = nullptr;
+
+ return NS_ERROR_XPATH_BAD_EXTENSION_FUNCTION;
+}
+
+Expr::ResultType txErrorFunctionCall::getReturnType() {
+ // It doesn't really matter what we return here, but it might
+ // be a good idea to try to keep this as unoptimizable as possible
+ return ANY_RESULT;
+}
+
+bool txErrorFunctionCall::isSensitiveTo(ContextSensitivity aContext) {
+ // It doesn't really matter what we return here, but it might
+ // be a good idea to try to keep this as unoptimizable as possible
+ return true;
+}
+
+#ifdef TX_TO_STRING
+void txErrorFunctionCall::appendName(nsAString& aDest) {
+ aDest.Append(mName->GetUTF16String());
+}
+#endif
+
+static nsresult TX_ConstructXSLTFunction(nsAtom* aName,
+ txStylesheetCompilerState* aState,
+ FunctionCall** aFunction) {
+ if (aName == nsGkAtoms::document) {
+ *aFunction = new DocumentFunctionCall(aState->mElementContext->mBaseURI);
+ } else if (aName == nsGkAtoms::key) {
+ if (!aState->allowed(txIParseContext::KEY_FUNCTION)) {
+ return NS_ERROR_XSLT_CALL_TO_KEY_NOT_ALLOWED;
+ }
+ *aFunction = new txKeyFunctionCall(aState->mElementContext->mMappings);
+ } else if (aName == nsGkAtoms::formatNumber) {
+ *aFunction = new txFormatNumberFunctionCall(
+ aState->mStylesheet, aState->mElementContext->mMappings);
+ } else if (aName == nsGkAtoms::current) {
+ *aFunction = new CurrentFunctionCall();
+ } else if (aName == nsGkAtoms::unparsedEntityUri) {
+ return NS_ERROR_NOT_IMPLEMENTED;
+ } else if (aName == nsGkAtoms::generateId) {
+ *aFunction = new GenerateIdFunctionCall();
+ } else if (aName == nsGkAtoms::systemProperty) {
+ *aFunction = new txXSLTEnvironmentFunctionCall(
+ txXSLTEnvironmentFunctionCall::SYSTEM_PROPERTY,
+ aState->mElementContext->mMappings);
+ } else if (aName == nsGkAtoms::elementAvailable) {
+ *aFunction = new txXSLTEnvironmentFunctionCall(
+ txXSLTEnvironmentFunctionCall::ELEMENT_AVAILABLE,
+ aState->mElementContext->mMappings);
+ } else if (aName == nsGkAtoms::functionAvailable) {
+ *aFunction = new txXSLTEnvironmentFunctionCall(
+ txXSLTEnvironmentFunctionCall::FUNCTION_AVAILABLE,
+ aState->mElementContext->mMappings);
+ } else {
+ return NS_ERROR_XPATH_UNKNOWN_FUNCTION;
+ }
+
+ MOZ_ASSERT(*aFunction);
+ return NS_OK;
+}
+
+extern nsresult TX_ConstructEXSLTFunction(nsAtom* aName, int32_t aNamespaceID,
+ txStylesheetCompilerState* aState,
+ FunctionCall** aResult);
+
+static nsresult findFunction(nsAtom* aName, int32_t aNamespaceID,
+ txStylesheetCompilerState* aState,
+ FunctionCall** aResult) {
+ if (aNamespaceID == kNameSpaceID_None) {
+ return TX_ConstructXSLTFunction(aName, aState, aResult);
+ }
+
+ return TX_ConstructEXSLTFunction(aName, aNamespaceID, aState, aResult);
+}
+
+extern bool TX_XSLTFunctionAvailable(nsAtom* aName, int32_t aNameSpaceID) {
+ RefPtr<txStylesheetCompiler> compiler =
+ new txStylesheetCompiler(u""_ns, ReferrerPolicy::_empty, nullptr);
+ NS_ENSURE_TRUE(compiler, false);
+
+ UniquePtr<FunctionCall> fnCall;
+
+ return NS_SUCCEEDED(
+ findFunction(aName, aNameSpaceID, compiler, getter_Transfers(fnCall)));
+}
+
+nsresult txStylesheetCompilerState::resolveFunctionCall(
+ nsAtom* aName, int32_t aID, FunctionCall** aFunction) {
+ *aFunction = nullptr;
+
+ nsresult rv = findFunction(aName, aID, this, aFunction);
+ if (rv == NS_ERROR_XPATH_UNKNOWN_FUNCTION &&
+ (aID != kNameSpaceID_None || fcp())) {
+ *aFunction = new txErrorFunctionCall(aName);
+ rv = NS_OK;
+ }
+
+ return rv;
+}
+
+bool txStylesheetCompilerState::caseInsensitiveNameTests() { return false; }
+
+void txStylesheetCompilerState::SetErrorOffset(uint32_t aOffset) {
+ // XXX implement me
+}
+
+txElementContext::txElementContext(const nsAString& aBaseURI)
+ : mPreserveWhitespace(false),
+ mForwardsCompatibleParsing(true),
+ mBaseURI(aBaseURI),
+ mMappings(new txNamespaceMap),
+ mDepth(0) {
+ mInstructionNamespaces.AppendElement(kNameSpaceID_XSLT);
+}
+
+txElementContext::txElementContext(const txElementContext& aOther)
+ : mPreserveWhitespace(aOther.mPreserveWhitespace),
+ mForwardsCompatibleParsing(aOther.mForwardsCompatibleParsing),
+ mBaseURI(aOther.mBaseURI),
+ mMappings(aOther.mMappings),
+ mDepth(0) {
+ mInstructionNamespaces = aOther.mInstructionNamespaces.Clone();
+}
diff --git a/dom/xslt/xslt/txStylesheetCompiler.h b/dom/xslt/xslt/txStylesheetCompiler.h
new file mode 100644
index 0000000000..759219ced6
--- /dev/null
+++ b/dom/xslt/xslt/txStylesheetCompiler.h
@@ -0,0 +1,234 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef TRANSFRMX_TXSTYLESHEETCOMPILER_H
+#define TRANSFRMX_TXSTYLESHEETCOMPILER_H
+
+#include "mozilla/Attributes.h"
+#include "mozilla/UniquePtr.h"
+#include "txStack.h"
+#include "txXSLTPatterns.h"
+#include "txExpr.h"
+#include "txIXPathContext.h"
+#include "txStylesheet.h"
+#include "nsTArray.h"
+
+extern bool TX_XSLTFunctionAvailable(nsAtom* aName, int32_t aNameSpaceID);
+
+class txHandlerTable;
+class txElementContext;
+class txInstructionContainer;
+class txInstruction;
+class txNamespaceMap;
+class txToplevelItem;
+class txPushNewContext;
+class txStylesheetCompiler;
+
+class txElementContext : public txObject {
+ public:
+ explicit txElementContext(const nsAString& aBaseURI);
+ txElementContext(const txElementContext& aOther);
+
+ bool mPreserveWhitespace;
+ bool mForwardsCompatibleParsing;
+ nsString mBaseURI;
+ RefPtr<txNamespaceMap> mMappings;
+ nsTArray<int32_t> mInstructionNamespaces;
+ int32_t mDepth;
+};
+
+using mozilla::dom::ReferrerPolicy;
+
+class txACompileObserver {
+ public:
+ NS_INLINE_DECL_PURE_VIRTUAL_REFCOUNTING
+
+ virtual nsresult loadURI(const nsAString& aUri, const nsAString& aReferrerUri,
+ ReferrerPolicy aReferrerPolicy,
+ txStylesheetCompiler* aCompiler) = 0;
+ virtual void onDoneCompiling(txStylesheetCompiler* aCompiler,
+ nsresult aResult,
+ const char16_t* aErrorText = nullptr,
+ const char16_t* aParam = nullptr) = 0;
+};
+
+#define TX_DECL_ACOMPILEOBSERVER \
+ nsresult loadURI(const nsAString& aUri, const nsAString& aReferrerUri, \
+ ReferrerPolicy aReferrerPolicy, \
+ txStylesheetCompiler* aCompiler) override; \
+ void onDoneCompiling(txStylesheetCompiler* aCompiler, nsresult aResult, \
+ const char16_t* aErrorText = nullptr, \
+ const char16_t* aParam = nullptr) override;
+
+class txInScopeVariable {
+ public:
+ explicit txInScopeVariable(const txExpandedName& aName)
+ : mName(aName), mLevel(1) {}
+ txExpandedName mName;
+ int32_t mLevel;
+};
+
+class txStylesheetCompilerState : public txIParseContext {
+ public:
+ explicit txStylesheetCompilerState(txACompileObserver* aObserver);
+ ~txStylesheetCompilerState();
+
+ nsresult init(const nsAString& aStylesheetURI, ReferrerPolicy aReferrerPolicy,
+ txStylesheet* aStylesheet, txListIterator* aInsertPosition);
+
+ // Embedded stylesheets state
+ bool handleEmbeddedSheet() { return mEmbedStatus == eInEmbed; }
+ void doneEmbedding() { mEmbedStatus = eHasEmbed; }
+
+ // Stack functions
+ enum enumStackType {
+ eElementHandler,
+ eHandlerTable,
+ eVariableItem,
+ eCopy,
+ eInstruction,
+ ePushNewContext,
+ eConditionalGoto,
+ eCheckParam,
+ ePushNullTemplateRule
+ };
+ void pushHandlerTable(txHandlerTable* aTable);
+ void popHandlerTable();
+ void pushSorter(txPushNewContext* aSorter);
+ void popSorter();
+ void pushChooseGotoList();
+ void popChooseGotoList();
+ void pushObject(txObject* aObject);
+ txObject* popObject();
+ void pushPtr(void* aPtr, enumStackType aType);
+ void* popPtr(enumStackType aType);
+
+ // stylesheet functions
+ void addToplevelItem(txToplevelItem* aItem);
+ nsresult openInstructionContainer(txInstructionContainer* aContainer);
+ void closeInstructionContainer();
+ txInstruction* addInstruction(
+ mozilla::UniquePtr<txInstruction>&& aInstruction);
+ template <class T>
+ T* addInstruction(mozilla::UniquePtr<T> aInstruction) {
+ return static_cast<T*>(addInstruction(
+ mozilla::UniquePtr<txInstruction>(std::move(aInstruction))));
+ }
+ nsresult loadIncludedStylesheet(const nsAString& aURI);
+ nsresult loadImportedStylesheet(const nsAString& aURI,
+ txStylesheet::ImportFrame* aFrame);
+
+ // misc
+ void addGotoTarget(txInstruction** aTargetPointer);
+ void addVariable(const txExpandedName& aName);
+
+ // txIParseContext
+ nsresult resolveNamespacePrefix(nsAtom* aPrefix, int32_t& aID) override;
+ nsresult resolveFunctionCall(nsAtom* aName, int32_t aID,
+ FunctionCall** aFunction) override;
+ bool caseInsensitiveNameTests() override;
+
+ /**
+ * Should the stylesheet be parsed in forwards compatible parsing mode.
+ */
+ bool fcp() { return mElementContext->mForwardsCompatibleParsing; }
+
+ void SetErrorOffset(uint32_t aOffset) override;
+
+ bool allowed(Allowed aAllowed) override { return !(mDisAllowed & aAllowed); }
+
+ bool ignoreError(nsresult aResult) {
+ // Some errors shouldn't be ignored even in forwards compatible parsing
+ // mode.
+ return aResult != NS_ERROR_XSLT_CALL_TO_KEY_NOT_ALLOWED && fcp();
+ }
+
+ RefPtr<txStylesheet> mStylesheet;
+ txHandlerTable* mHandlerTable;
+ mozilla::UniquePtr<txElementContext> mElementContext;
+ txPushNewContext* mSorter;
+ mozilla::UniquePtr<txList> mChooseGotoList;
+ bool mDOE;
+ bool mSearchingForFallback;
+ uint16_t mDisAllowed;
+
+ protected:
+ RefPtr<txACompileObserver> mObserver;
+ nsTArray<txInScopeVariable> mInScopeVariables;
+ nsTArray<txStylesheetCompiler*> mChildCompilerList;
+ // embed info, target information is the ID
+ nsString mTarget;
+ enum { eNoEmbed, eNeedEmbed, eInEmbed, eHasEmbed } mEmbedStatus;
+ nsString mStylesheetURI;
+ bool mIsTopCompiler;
+ bool mDoneWithThisStylesheet;
+ txStack mObjectStack;
+ txStack mOtherStack;
+ nsTArray<enumStackType> mTypeStack;
+
+ private:
+ mozilla::UniquePtr<txInstruction>* mNextInstrPtr;
+ txListIterator mToplevelIterator;
+ nsTArray<txInstruction**> mGotoTargetPointers;
+ ReferrerPolicy mReferrerPolicy;
+};
+
+struct txStylesheetAttr {
+ int32_t mNamespaceID;
+ RefPtr<nsAtom> mLocalName;
+ RefPtr<nsAtom> mPrefix;
+ nsString mValue;
+};
+
+class txStylesheetCompiler final : private txStylesheetCompilerState,
+ public txACompileObserver {
+ public:
+ friend class txStylesheetCompilerState;
+ friend bool TX_XSLTFunctionAvailable(nsAtom* aName, int32_t aNameSpaceID);
+ txStylesheetCompiler(const nsAString& aStylesheetURI,
+ ReferrerPolicy aReferrerPolicy,
+ txACompileObserver* aObserver);
+ txStylesheetCompiler(const nsAString& aStylesheetURI,
+ txStylesheet* aStylesheet,
+ txListIterator* aInsertPosition,
+ ReferrerPolicy aReferrerPolicy,
+ txACompileObserver* aObserver);
+
+ void setBaseURI(const nsString& aBaseURI);
+
+ nsresult startElement(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix, txStylesheetAttr* aAttributes,
+ int32_t aAttrCount);
+ nsresult startElement(const char16_t* aName, const char16_t** aAtts,
+ int32_t aAttrCount);
+ nsresult endElement();
+ nsresult characters(const nsAString& aStr);
+ nsresult doneLoading();
+
+ void cancel(nsresult aError, const char16_t* aErrorText = nullptr,
+ const char16_t* aParam = nullptr);
+
+ txStylesheet* getStylesheet();
+
+ TX_DECL_ACOMPILEOBSERVER
+ NS_INLINE_DECL_REFCOUNTING(txStylesheetCompiler, override)
+
+ private:
+ // Private destructor, to discourage deletion outside of Release():
+ ~txStylesheetCompiler() = default;
+
+ nsresult startElementInternal(int32_t aNamespaceID, nsAtom* aLocalName,
+ nsAtom* aPrefix, txStylesheetAttr* aAttributes,
+ int32_t aAttrCount);
+
+ nsresult flushCharacters();
+ nsresult ensureNewElementContext();
+ nsresult maybeDoneCompiling();
+
+ nsString mCharacters;
+ nsresult mStatus;
+};
+
+#endif
diff --git a/dom/xslt/xslt/txTextHandler.cpp b/dom/xslt/xslt/txTextHandler.cpp
new file mode 100644
index 0000000000..0147c7a94d
--- /dev/null
+++ b/dom/xslt/xslt/txTextHandler.cpp
@@ -0,0 +1,60 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txTextHandler.h"
+#include "nsAString.h"
+
+txTextHandler::txTextHandler(bool aOnlyText)
+ : mLevel(0), mOnlyText(aOnlyText) {}
+
+nsresult txTextHandler::attribute(nsAtom* aPrefix, nsAtom* aLocalName,
+ nsAtom* aLowercaseLocalName, int32_t aNsID,
+ const nsString& aValue) {
+ return NS_OK;
+}
+
+nsresult txTextHandler::attribute(nsAtom* aPrefix, const nsAString& aLocalName,
+ const int32_t aNsID, const nsString& aValue) {
+ return NS_OK;
+}
+
+nsresult txTextHandler::characters(const nsAString& aData, bool aDOE) {
+ if (mLevel == 0) mValue.Append(aData);
+
+ return NS_OK;
+}
+
+nsresult txTextHandler::comment(const nsString& aData) { return NS_OK; }
+
+nsresult txTextHandler::endDocument(nsresult aResult) { return NS_OK; }
+
+nsresult txTextHandler::endElement() {
+ if (mOnlyText) --mLevel;
+
+ return NS_OK;
+}
+
+nsresult txTextHandler::processingInstruction(const nsString& aTarget,
+ const nsString& aData) {
+ return NS_OK;
+}
+
+nsresult txTextHandler::startDocument() { return NS_OK; }
+
+nsresult txTextHandler::startElement(nsAtom* aPrefix, nsAtom* aLocalName,
+ nsAtom* aLowercaseLocalName,
+ const int32_t aNsID) {
+ if (mOnlyText) ++mLevel;
+
+ return NS_OK;
+}
+
+nsresult txTextHandler::startElement(nsAtom* aPrefix,
+ const nsAString& aLocalName,
+ const int32_t aNsID) {
+ if (mOnlyText) ++mLevel;
+
+ return NS_OK;
+}
diff --git a/dom/xslt/xslt/txTextHandler.h b/dom/xslt/xslt/txTextHandler.h
new file mode 100644
index 0000000000..7c41e3ec7a
--- /dev/null
+++ b/dom/xslt/xslt/txTextHandler.h
@@ -0,0 +1,25 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef TRANSFRMX_TEXT_HANDLER_H
+#define TRANSFRMX_TEXT_HANDLER_H
+
+#include "txXMLEventHandler.h"
+#include "nsString.h"
+
+class txTextHandler : public txAXMLEventHandler {
+ public:
+ explicit txTextHandler(bool aOnlyText);
+
+ TX_DECL_TXAXMLEVENTHANDLER
+
+ nsString mValue;
+
+ private:
+ uint32_t mLevel;
+ bool mOnlyText;
+};
+
+#endif
diff --git a/dom/xslt/xslt/txToplevelItems.cpp b/dom/xslt/xslt/txToplevelItems.cpp
new file mode 100644
index 0000000000..204111cc25
--- /dev/null
+++ b/dom/xslt/xslt/txToplevelItems.cpp
@@ -0,0 +1,45 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txToplevelItems.h"
+
+#include <utility>
+
+#include "txInstructions.h"
+#include "txStylesheet.h"
+#include "txXSLTPatterns.h"
+
+using mozilla::UniquePtr;
+
+TX_IMPL_GETTYPE(txAttributeSetItem, txToplevelItem::attributeSet)
+TX_IMPL_GETTYPE(txImportItem, txToplevelItem::import)
+TX_IMPL_GETTYPE(txOutputItem, txToplevelItem::output)
+TX_IMPL_GETTYPE(txDummyItem, txToplevelItem::dummy)
+
+TX_IMPL_GETTYPE(txStripSpaceItem, txToplevelItem::stripSpace)
+
+txStripSpaceItem::~txStripSpaceItem() {
+ int32_t i, count = mStripSpaceTests.Length();
+ for (i = 0; i < count; ++i) {
+ delete mStripSpaceTests[i];
+ }
+}
+
+void txStripSpaceItem::addStripSpaceTest(txStripSpaceTest* aStripSpaceTest) {
+ mStripSpaceTests.AppendElement(aStripSpaceTest);
+}
+
+TX_IMPL_GETTYPE(txTemplateItem, txToplevelItem::templ)
+
+txTemplateItem::txTemplateItem(UniquePtr<txPattern>&& aMatch,
+ const txExpandedName& aName,
+ const txExpandedName& aMode, double aPrio)
+ : mMatch(std::move(aMatch)), mName(aName), mMode(aMode), mPrio(aPrio) {}
+
+TX_IMPL_GETTYPE(txVariableItem, txToplevelItem::variable)
+
+txVariableItem::txVariableItem(const txExpandedName& aName,
+ UniquePtr<Expr>&& aValue, bool aIsParam)
+ : mName(aName), mValue(std::move(aValue)), mIsParam(aIsParam) {}
diff --git a/dom/xslt/xslt/txToplevelItems.h b/dom/xslt/xslt/txToplevelItems.h
new file mode 100644
index 0000000000..a8ae7d44ef
--- /dev/null
+++ b/dom/xslt/xslt/txToplevelItems.h
@@ -0,0 +1,118 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef TRANSFRMX_TXTOPLEVELITEMS_H
+#define TRANSFRMX_TXTOPLEVELITEMS_H
+
+#include "nsError.h"
+#include "txOutputFormat.h"
+#include "txXMLUtils.h"
+#include "txStylesheet.h"
+#include "txInstructions.h"
+
+class txPattern;
+class Expr;
+
+class txToplevelItem {
+ public:
+ MOZ_COUNTED_DEFAULT_CTOR(txToplevelItem)
+ MOZ_COUNTED_DTOR_VIRTUAL(txToplevelItem)
+
+ enum type {
+ attributeSet,
+ dummy,
+ import,
+ // namespaceAlias,
+ output,
+ stripSpace, // also used for preserve-space
+ templ,
+ variable
+ };
+
+ virtual type getType() = 0;
+};
+
+#define TX_DECL_TOPLEVELITEM virtual type getType() override;
+#define TX_IMPL_GETTYPE(_class, _type) \
+ txToplevelItem::type _class::getType() { return _type; }
+
+class txInstructionContainer : public txToplevelItem {
+ public:
+ mozilla::UniquePtr<txInstruction> mFirstInstruction;
+};
+
+// xsl:attribute-set
+class txAttributeSetItem : public txInstructionContainer {
+ public:
+ explicit txAttributeSetItem(const txExpandedName aName) : mName(aName) {}
+
+ TX_DECL_TOPLEVELITEM
+
+ txExpandedName mName;
+};
+
+// xsl:import
+class txImportItem : public txToplevelItem {
+ public:
+ TX_DECL_TOPLEVELITEM
+
+ mozilla::UniquePtr<txStylesheet::ImportFrame> mFrame;
+};
+
+// xsl:output
+class txOutputItem : public txToplevelItem {
+ public:
+ TX_DECL_TOPLEVELITEM
+
+ txOutputFormat mFormat;
+};
+
+// insertionpoint for xsl:include
+class txDummyItem : public txToplevelItem {
+ public:
+ TX_DECL_TOPLEVELITEM
+};
+
+// xsl:strip-space and xsl:preserve-space
+class txStripSpaceItem : public txToplevelItem {
+ public:
+ ~txStripSpaceItem();
+
+ TX_DECL_TOPLEVELITEM
+
+ void addStripSpaceTest(txStripSpaceTest* aStripSpaceTest);
+
+ nsTArray<txStripSpaceTest*> mStripSpaceTests;
+};
+
+// xsl:template
+class txTemplateItem : public txInstructionContainer {
+ public:
+ txTemplateItem(mozilla::UniquePtr<txPattern>&& aMatch,
+ const txExpandedName& aName, const txExpandedName& aMode,
+ double aPrio);
+
+ TX_DECL_TOPLEVELITEM
+
+ mozilla::UniquePtr<txPattern> mMatch;
+ txExpandedName mName;
+ txExpandedName mMode;
+ double mPrio;
+};
+
+// xsl:variable at top level
+class txVariableItem : public txInstructionContainer {
+ public:
+ txVariableItem(const txExpandedName& aName, mozilla::UniquePtr<Expr>&& aValue,
+ bool aIsParam);
+
+ TX_DECL_TOPLEVELITEM
+
+ txExpandedName mName;
+ mozilla::UniquePtr<Expr> mValue;
+ bool mIsParam;
+};
+
+#endif // TRANSFRMX_TXTOPLEVELITEMS_H
diff --git a/dom/xslt/xslt/txUnknownHandler.cpp b/dom/xslt/xslt/txUnknownHandler.cpp
new file mode 100644
index 0000000000..7f13418941
--- /dev/null
+++ b/dom/xslt/xslt/txUnknownHandler.cpp
@@ -0,0 +1,177 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txUnknownHandler.h"
+
+#include <utility>
+
+#include "mozilla/UniquePtrExtensions.h"
+#include "nsGkAtoms.h"
+#include "txExecutionState.h"
+#include "txStringUtils.h"
+#include "txStylesheet.h"
+
+using mozilla::UniquePtr;
+using mozilla::WrapUnique;
+
+txUnknownHandler::txUnknownHandler(txExecutionState* aEs)
+ : mEs(aEs), mFlushed(false) {
+ MOZ_COUNT_CTOR_INHERITED(txUnknownHandler, txBufferingHandler);
+}
+
+txUnknownHandler::~txUnknownHandler() {
+ MOZ_COUNT_DTOR_INHERITED(txUnknownHandler, txBufferingHandler);
+}
+
+nsresult txUnknownHandler::attribute(nsAtom* aPrefix, nsAtom* aLocalName,
+ nsAtom* aLowercaseLocalName, int32_t aNsID,
+ const nsString& aValue) {
+ return mFlushed
+ ? mEs->mResultHandler->attribute(
+ aPrefix, aLocalName, aLowercaseLocalName, aNsID, aValue)
+ : txBufferingHandler::attribute(
+ aPrefix, aLocalName, aLowercaseLocalName, aNsID, aValue);
+}
+
+nsresult txUnknownHandler::attribute(nsAtom* aPrefix,
+ const nsAString& aLocalName,
+ const int32_t aNsID,
+ const nsString& aValue) {
+ return mFlushed ? mEs->mResultHandler->attribute(aPrefix, aLocalName, aNsID,
+ aValue)
+ : txBufferingHandler::attribute(aPrefix, aLocalName, aNsID,
+ aValue);
+}
+
+nsresult txUnknownHandler::characters(const nsAString& aData, bool aDOE) {
+ return mFlushed ? mEs->mResultHandler->characters(aData, aDOE)
+ : txBufferingHandler::characters(aData, aDOE);
+}
+
+nsresult txUnknownHandler::comment(const nsString& aData) {
+ return mFlushed ? mEs->mResultHandler->comment(aData)
+ : txBufferingHandler::comment(aData);
+}
+
+nsresult txUnknownHandler::endDocument(nsresult aResult) {
+ if (!mFlushed) {
+ if (NS_FAILED(aResult)) {
+ return NS_OK;
+ }
+
+ // This is an unusual case, no output method has been set and we
+ // didn't create a document element. Switching to XML output mode
+ // anyway.
+
+ // Make sure that mEs->mResultHandler == this is true, otherwise we'll
+ // leak mEs->mResultHandler in createHandlerAndFlush.
+ NS_ASSERTION(mEs->mResultHandler == this,
+ "We're leaking mEs->mResultHandler.");
+
+ nsresult rv = createHandlerAndFlush(false, u""_ns, kNameSpaceID_None);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ return mEs->mResultHandler->endDocument(aResult);
+}
+
+nsresult txUnknownHandler::endElement() {
+ return mFlushed ? mEs->mResultHandler->endElement()
+ : txBufferingHandler::endElement();
+}
+
+nsresult txUnknownHandler::processingInstruction(const nsString& aTarget,
+ const nsString& aData) {
+ return mFlushed ? mEs->mResultHandler->processingInstruction(aTarget, aData)
+ : txBufferingHandler::processingInstruction(aTarget, aData);
+}
+
+nsresult txUnknownHandler::startDocument() {
+ return mFlushed ? mEs->mResultHandler->startDocument()
+ : txBufferingHandler::startDocument();
+}
+
+nsresult txUnknownHandler::startElement(nsAtom* aPrefix, nsAtom* aLocalName,
+ nsAtom* aLowercaseLocalName,
+ int32_t aNsID) {
+ if (!mFlushed) {
+ // Make sure that mEs->mResultHandler == this is true, otherwise we'll
+ // leak mEs->mResultHandler in createHandlerAndFlush.
+ NS_ASSERTION(mEs->mResultHandler == this,
+ "We're leaking mEs->mResultHandler.");
+
+ RefPtr<nsAtom> owner;
+ if (!aLowercaseLocalName) {
+ owner = TX_ToLowerCaseAtom(aLocalName);
+ NS_ENSURE_TRUE(owner, NS_ERROR_OUT_OF_MEMORY);
+
+ aLowercaseLocalName = owner;
+ }
+
+ bool htmlRoot = aNsID == kNameSpaceID_None && !aPrefix &&
+ aLowercaseLocalName == nsGkAtoms::html;
+
+ // Use aLocalName and not aLowercaseLocalName in case the output
+ // handler cares about case. For eHTMLOutput the handler will hardcode
+ // to 'html' anyway.
+ nsresult rv = createHandlerAndFlush(
+ htmlRoot, nsDependentAtomString(aLocalName), aNsID);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ return mEs->mResultHandler->startElement(aPrefix, aLocalName,
+ aLowercaseLocalName, aNsID);
+}
+
+nsresult txUnknownHandler::startElement(nsAtom* aPrefix,
+ const nsAString& aLocalName,
+ const int32_t aNsID) {
+ if (!mFlushed) {
+ // Make sure that mEs->mResultHandler == this is true, otherwise we'll
+ // leak mEs->mResultHandler in createHandlerAndFlush.
+ NS_ASSERTION(mEs->mResultHandler == this,
+ "We're leaking mEs->mResultHandler.");
+
+ bool htmlRoot =
+ aNsID == kNameSpaceID_None && !aPrefix &&
+ aLocalName.Equals(u"html"_ns, nsCaseInsensitiveStringComparator);
+ nsresult rv = createHandlerAndFlush(htmlRoot, aLocalName, aNsID);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ return mEs->mResultHandler->startElement(aPrefix, aLocalName, aNsID);
+}
+
+nsresult txUnknownHandler::createHandlerAndFlush(bool aHTMLRoot,
+ const nsAString& aName,
+ const int32_t aNsID) {
+ NS_ENSURE_TRUE(mBuffer, NS_ERROR_NOT_INITIALIZED);
+
+ txOutputFormat format;
+ format.merge(*(mEs->mStylesheet->getOutputFormat()));
+ if (format.mMethod == eMethodNotSet) {
+ format.mMethod = aHTMLRoot ? eHTMLOutput : eXMLOutput;
+ }
+
+ UniquePtr<txAXMLEventHandler> handler;
+ nsresult rv = mEs->mOutputHandlerFactory->createHandlerWith(
+ &format, aName, aNsID, getter_Transfers(handler));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ mEs->mOutputHandler = handler.get();
+ mEs->mResultHandler = handler.release();
+ // Let the executionstate delete us. We need to stay alive because we might
+ // need to forward hooks to mEs->mResultHandler if someone is currently
+ // flushing a buffer to mEs->mResultHandler.
+ mEs->mObsoleteHandler = WrapUnique(this);
+
+ mFlushed = true;
+
+ // Let go of out buffer as soon as we're done flushing it, we're not going
+ // to need it anymore from this point on (all hooks get forwarded to
+ // mEs->mResultHandler.
+ UniquePtr<txResultBuffer> buffer(std::move(mBuffer));
+ return buffer->flushToHandler(mEs->mResultHandler);
+}
diff --git a/dom/xslt/xslt/txUnknownHandler.h b/dom/xslt/xslt/txUnknownHandler.h
new file mode 100644
index 0000000000..3b13edcfc9
--- /dev/null
+++ b/dom/xslt/xslt/txUnknownHandler.h
@@ -0,0 +1,37 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef txUnknownHandler_h___
+#define txUnknownHandler_h___
+
+#include "txBufferingHandler.h"
+#include "txOutputFormat.h"
+
+class txExecutionState;
+
+class txUnknownHandler : public txBufferingHandler {
+ public:
+ explicit txUnknownHandler(txExecutionState* aEs);
+ virtual ~txUnknownHandler();
+
+ TX_DECL_TXAXMLEVENTHANDLER
+
+ private:
+ nsresult createHandlerAndFlush(bool aHTMLRoot, const nsAString& aName,
+ const int32_t aNsID);
+
+ /*
+ * XXX we shouldn't hold to the txExecutionState, as we're supposed
+ * to live without it. But as a standalone handler, we don't.
+ * The right fix may need a txOutputFormat here.
+ */
+ txExecutionState* mEs;
+
+ // If mFlushed is true then we've replaced mEs->mResultHandler with a
+ // different handler and we should forward to that handler.
+ bool mFlushed;
+};
+
+#endif /* txUnknownHandler_h___ */
diff --git a/dom/xslt/xslt/txVariableMap.h b/dom/xslt/xslt/txVariableMap.h
new file mode 100644
index 0000000000..167eade697
--- /dev/null
+++ b/dom/xslt/xslt/txVariableMap.h
@@ -0,0 +1,88 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef TRANSFRMX_VARIABLEMAP_H
+#define TRANSFRMX_VARIABLEMAP_H
+
+#include "nsError.h"
+#include "txXMLUtils.h"
+#include "txExprResult.h"
+#include "txExpandedNameMap.h"
+
+/**
+ * Map that maps from expanded name to an expression result value. This is just
+ * a base class, use txVariableMap or txParameterMap instead.
+ */
+class txVariableMapBase {
+ public:
+ nsresult bindVariable(const txExpandedName& aName, txAExprResult* aValue);
+
+ void getVariable(const txExpandedName& aName, txAExprResult** aResult);
+
+ void removeVariable(const txExpandedName& aName);
+
+ protected:
+ txVariableMapBase() = default;
+ ~txVariableMapBase();
+
+ txExpandedNameMap<txAExprResult> mMap;
+};
+
+/**
+ * Map for mapping from expanded name to variable values. This is not
+ * refcounted, so owners need to be careful to clean this up.
+ */
+class txVariableMap : public txVariableMapBase {
+ public:
+ txVariableMap() : txVariableMapBase() { MOZ_COUNT_CTOR(txVariableMap); }
+ MOZ_COUNTED_DTOR(txVariableMap)
+};
+
+/**
+ * Map for mapping from expanded name to parameter values. This is refcounted,
+ * so multiple owners can hold a reference.
+ */
+class txParameterMap : public txVariableMapBase {
+ public:
+ NS_INLINE_DECL_REFCOUNTING(txParameterMap)
+
+ private:
+ ~txParameterMap() = default;
+};
+
+inline txVariableMapBase::~txVariableMapBase() {
+ txExpandedNameMap<txAExprResult>::iterator iter(mMap);
+ while (iter.next()) {
+ txAExprResult* res = iter.value();
+ NS_RELEASE(res);
+ }
+}
+
+inline nsresult txVariableMapBase::bindVariable(const txExpandedName& aName,
+ txAExprResult* aValue) {
+ NS_ASSERTION(aValue, "can't add null-variables to a txVariableMap");
+ nsresult rv = mMap.add(aName, aValue);
+ if (NS_SUCCEEDED(rv)) {
+ NS_ADDREF(aValue);
+ } else if (rv == NS_ERROR_XSLT_ALREADY_SET) {
+ rv = NS_ERROR_XSLT_VAR_ALREADY_SET;
+ }
+ return rv;
+}
+
+inline void txVariableMapBase::getVariable(const txExpandedName& aName,
+ txAExprResult** aResult) {
+ *aResult = mMap.get(aName);
+ if (*aResult) {
+ NS_ADDREF(*aResult);
+ }
+}
+
+inline void txVariableMapBase::removeVariable(const txExpandedName& aName) {
+ txAExprResult* var = mMap.remove(aName);
+ NS_IF_RELEASE(var);
+}
+
+#endif // TRANSFRMX_VARIABLEMAP_H
diff --git a/dom/xslt/xslt/txXMLEventHandler.h b/dom/xslt/xslt/txXMLEventHandler.h
new file mode 100644
index 0000000000..7e173bdab6
--- /dev/null
+++ b/dom/xslt/xslt/txXMLEventHandler.h
@@ -0,0 +1,184 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef TRANSFRMX_XML_EVENT_HANDLER_H
+#define TRANSFRMX_XML_EVENT_HANDLER_H
+
+#include "txCore.h"
+#include "nsAtom.h"
+
+#define kTXNameSpaceURI u"http://www.mozilla.org/TransforMiix"
+#define kTXWrapper "transformiix:result"
+
+class txOutputFormat;
+namespace mozilla::dom {
+class Document;
+} // namespace mozilla::dom
+
+/**
+ * An interface for handling XML documents, loosely modeled
+ * after Dave Megginson's SAX 1.0 API.
+ */
+
+class txAXMLEventHandler {
+ public:
+ virtual ~txAXMLEventHandler() = default;
+
+ /**
+ * Signals to receive the start of an attribute.
+ *
+ * @param aPrefix the prefix of the attribute
+ * @param aLocalName the localname of the attribute
+ * @param aLowercaseName the localname of the attribute in lower case
+ * @param aNsID the namespace ID of the attribute
+ * @param aValue the value of the attribute
+ */
+ virtual nsresult attribute(nsAtom* aPrefix, nsAtom* aLocalName,
+ nsAtom* aLowercaseLocalName, int32_t aNsID,
+ const nsString& aValue) = 0;
+
+ /**
+ * Signals to receive the start of an attribute.
+ *
+ * @param aPrefix the prefix of the attribute
+ * @param aLocalName the localname of the attribute
+ * @param aNsID the namespace ID of the attribute
+ * @param aValue the value of the attribute
+ */
+ virtual nsresult attribute(nsAtom* aPrefix, const nsAString& aLocalName,
+ const int32_t aNsID, const nsString& aValue) = 0;
+
+ /**
+ * Signals to receive characters.
+ *
+ * @param aData the characters to receive
+ * @param aDOE disable output escaping for these characters
+ */
+ virtual nsresult characters(const nsAString& aData, bool aDOE) = 0;
+
+ /**
+ * Signals to receive data that should be treated as a comment.
+ *
+ * @param data the comment data to receive
+ */
+ virtual nsresult comment(const nsString& aData) = 0;
+
+ /**
+ * Signals the end of a document. It is an error to call
+ * this method more than once.
+ */
+ virtual nsresult endDocument(nsresult aResult) = 0;
+
+ /**
+ * Signals to receive the end of an element.
+ */
+ virtual nsresult endElement() = 0;
+
+ /**
+ * Signals to receive a processing instruction.
+ *
+ * @param aTarget the target of the processing instruction
+ * @param aData the data of the processing instruction
+ */
+ virtual nsresult processingInstruction(const nsString& aTarget,
+ const nsString& aData) = 0;
+
+ /**
+ * Signals the start of a document.
+ */
+ virtual nsresult startDocument() = 0;
+
+ /**
+ * Signals to receive the start of an element.
+ *
+ * @param aPrefix the prefix of the element
+ * @param aLocalName the localname of the element
+ * @param aLowercaseName the localname of the element in lower case
+ * @param aNsID the namespace ID of the element
+ */
+ virtual nsresult startElement(nsAtom* aPrefix, nsAtom* aLocalName,
+ nsAtom* aLowercaseLocalName, int32_t aNsID) = 0;
+
+ /**
+ * Signals to receive the start of an element. Can throw
+ * NS_ERROR_XSLT_BAD_NODE_NAME if the name is invalid
+ *
+ * @param aPrefix the prefix of the element
+ * @param aLocalName the localname of the element
+ * @param aNsID the namespace ID of the element
+ */
+ virtual nsresult startElement(nsAtom* aPrefix, const nsAString& aLocalName,
+ const int32_t aNsID) = 0;
+};
+
+#define TX_DECL_TXAXMLEVENTHANDLER \
+ virtual nsresult attribute(nsAtom* aPrefix, nsAtom* aLocalName, \
+ nsAtom* aLowercaseLocalName, int32_t aNsID, \
+ const nsString& aValue) override; \
+ virtual nsresult attribute(nsAtom* aPrefix, const nsAString& aLocalName, \
+ const int32_t aNsID, const nsString& aValue) \
+ override; \
+ virtual nsresult characters(const nsAString& aData, bool aDOE) override; \
+ virtual nsresult comment(const nsString& aData) override; \
+ virtual nsresult endDocument(nsresult aResult = NS_OK) override; \
+ virtual nsresult endElement() override; \
+ virtual nsresult processingInstruction(const nsString& aTarget, \
+ const nsString& aData) override; \
+ virtual nsresult startDocument() override; \
+ virtual nsresult startElement(nsAtom* aPrefix, nsAtom* aLocalName, \
+ nsAtom* aLowercaseLocalName, int32_t aNsID) \
+ override; \
+ virtual nsresult startElement(nsAtom* aPrefix, const nsAString& aName, \
+ const int32_t aNsID) override;
+
+class txAOutputXMLEventHandler : public txAXMLEventHandler {
+ public:
+ /**
+ * Gets the Mozilla output document
+ *
+ * @param aDocument the Mozilla output document
+ */
+ virtual void getOutputDocument(mozilla::dom::Document** aDocument) = 0;
+};
+
+#define TX_DECL_TXAOUTPUTXMLEVENTHANDLER \
+ virtual void getOutputDocument(mozilla::dom::Document** aDocument) override;
+
+/**
+ * Interface used to create the appropriate outputhandler
+ */
+class txAOutputHandlerFactory {
+ public:
+ virtual ~txAOutputHandlerFactory() = default;
+
+ /**
+ * Creates an outputhandler for the specified format.
+ * @param aFromat format to get handler for
+ * @param aHandler outparam. The created handler
+ */
+ virtual nsresult createHandlerWith(txOutputFormat* aFormat,
+ txAXMLEventHandler** aHandler) = 0;
+
+ /**
+ * Creates an outputhandler for the specified format, with the specified
+ * name and namespace for the root element.
+ * @param aFromat format to get handler for
+ * @param aName name of the root element
+ * @param aNsID namespace-id of the root element
+ * @param aHandler outparam. The created handler
+ */
+ virtual nsresult createHandlerWith(txOutputFormat* aFormat,
+ const nsAString& aName, int32_t aNsID,
+ txAXMLEventHandler** aHandler) = 0;
+};
+
+#define TX_DECL_TXAOUTPUTHANDLERFACTORY \
+ nsresult createHandlerWith(txOutputFormat* aFormat, \
+ txAXMLEventHandler** aHandler) override; \
+ nsresult createHandlerWith(txOutputFormat* aFormat, const nsAString& aName, \
+ int32_t aNsID, txAXMLEventHandler** aHandler) \
+ override;
+
+#endif
diff --git a/dom/xslt/xslt/txXPathResultComparator.cpp b/dom/xslt/xslt/txXPathResultComparator.cpp
new file mode 100644
index 0000000000..6320a06b8e
--- /dev/null
+++ b/dom/xslt/xslt/txXPathResultComparator.cpp
@@ -0,0 +1,173 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/FloatingPoint.h"
+#include "mozilla/intl/Collator.h"
+#include "mozilla/intl/LocaleService.h"
+
+#include "txXPathResultComparator.h"
+#include "txExpr.h"
+#include "nsComponentManagerUtils.h"
+#include "txCore.h"
+
+using namespace mozilla;
+using Collator = mozilla::intl::Collator;
+
+#define kAscending (1 << 0)
+#define kUpperFirst (1 << 1)
+
+txResultStringComparator::txResultStringComparator(bool aAscending,
+ bool aUpperFirst,
+ const nsString& aLanguage) {
+ mSorting = 0;
+ if (aAscending) mSorting |= kAscending;
+ if (aUpperFirst) mSorting |= kUpperFirst;
+ nsresult rv = init(aLanguage);
+ if (NS_FAILED(rv)) NS_ERROR("Failed to initialize txResultStringComparator");
+}
+
+nsresult txResultStringComparator::init(const nsString& aLanguage) {
+ auto result =
+ aLanguage.IsEmpty()
+ ? mozilla::intl::LocaleService::TryCreateComponent<Collator>()
+ : mozilla::intl::LocaleService::TryCreateComponentWithLocale<
+ Collator>(NS_ConvertUTF16toUTF8(aLanguage).get());
+
+ NS_ENSURE_TRUE(result.isOk(), NS_ERROR_FAILURE);
+ auto collator = result.unwrap();
+
+ // Sort in a case-insensitive way, where "base" letters are considered
+ // equal, e.g: a = á, a = A, a ≠ b.
+ Collator::Options options{};
+ options.sensitivity = Collator::Sensitivity::Base;
+ auto optResult = collator->SetOptions(options);
+ NS_ENSURE_TRUE(optResult.isOk(), NS_ERROR_FAILURE);
+
+ mCollator = UniquePtr<const Collator>(collator.release());
+ return NS_OK;
+}
+
+nsresult txResultStringComparator::createSortableValue(Expr* aExpr,
+ txIEvalContext* aContext,
+ txObject*& aResult) {
+ UniquePtr<StringValue> val(new StringValue);
+
+ if (!mCollator) {
+ return NS_ERROR_FAILURE;
+ }
+
+ val->mCaseKeyString = MakeUnique<nsString>();
+ nsString& nsCaseKey = *val->mCaseKeyString;
+ nsresult rv = aExpr->evaluateToString(aContext, nsCaseKey);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (nsCaseKey.IsEmpty()) {
+ aResult = val.release();
+
+ return NS_OK;
+ }
+
+ auto result = mCollator->GetSortKey(nsCaseKey, val->mKey);
+ NS_ENSURE_TRUE(result.isOk(), NS_ERROR_FAILURE);
+
+ aResult = val.release();
+
+ return NS_OK;
+}
+
+int txResultStringComparator::compareValues(txObject* aVal1, txObject* aVal2) {
+ StringValue* strval1 = (StringValue*)aVal1;
+ StringValue* strval2 = (StringValue*)aVal2;
+
+ if (!mCollator) {
+ return -1;
+ }
+
+ if (strval1->mKey.Length() == 0) {
+ if (strval2->mKey.Length() == 0) {
+ return 0;
+ }
+ return ((mSorting & kAscending) ? -1 : 1);
+ }
+
+ if (strval2->mKey.Length() == 0) {
+ return ((mSorting & kAscending) ? 1 : -1);
+ }
+
+ nsresult rv;
+ int32_t result = mCollator->CompareSortKeys(strval1->mKey, strval2->mKey);
+
+ if (result != 0) {
+ return ((mSorting & kAscending) ? 1 : -1) * result;
+ }
+
+ if (strval1->mCaseKeyString && strval1->mKey.Length() != 0) {
+ rv = strval1->initCaseKey(*mCollator);
+ if (NS_FAILED(rv)) {
+ // XXX ErrorReport
+ return -1;
+ }
+ }
+ if (strval2->mCaseKeyString && strval2->mKey.Length() != 0) {
+ rv = strval2->initCaseKey(*mCollator);
+ if (NS_FAILED(rv)) {
+ // XXX ErrorReport
+ return -1;
+ }
+ }
+ result = mCollator->CompareSortKeys(strval1->mCaseKey, strval2->mCaseKey);
+
+ return ((mSorting & kAscending) ? 1 : -1) *
+ ((mSorting & kUpperFirst) ? -1 : 1) * result;
+}
+
+txResultStringComparator::StringValue::StringValue() = default;
+
+txResultStringComparator::StringValue::~StringValue() = default;
+
+nsresult txResultStringComparator::StringValue::initCaseKey(
+ const mozilla::intl::Collator& aCollator) {
+ auto result = aCollator.GetSortKey(*mCaseKeyString, mCaseKey);
+ if (result.isErr()) {
+ mCaseKey.SetLength(0);
+ return NS_ERROR_FAILURE;
+ }
+
+ mCaseKeyString = nullptr;
+ return NS_OK;
+}
+
+txResultNumberComparator::txResultNumberComparator(bool aAscending) {
+ mAscending = aAscending ? 1 : -1;
+}
+
+nsresult txResultNumberComparator::createSortableValue(Expr* aExpr,
+ txIEvalContext* aContext,
+ txObject*& aResult) {
+ UniquePtr<NumberValue> numval(new NumberValue);
+
+ RefPtr<txAExprResult> exprRes;
+ nsresult rv = aExpr->evaluate(aContext, getter_AddRefs(exprRes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ numval->mVal = exprRes->numberValue();
+
+ aResult = numval.release();
+
+ return NS_OK;
+}
+
+int txResultNumberComparator::compareValues(txObject* aVal1, txObject* aVal2) {
+ double dval1 = ((NumberValue*)aVal1)->mVal;
+ double dval2 = ((NumberValue*)aVal2)->mVal;
+
+ if (std::isnan(dval1)) return std::isnan(dval2) ? 0 : -mAscending;
+
+ if (std::isnan(dval2)) return mAscending;
+
+ if (dval1 == dval2) return 0;
+
+ return (dval1 < dval2) ? -mAscending : mAscending;
+}
diff --git a/dom/xslt/xslt/txXPathResultComparator.h b/dom/xslt/xslt/txXPathResultComparator.h
new file mode 100644
index 0000000000..273bbf4f1a
--- /dev/null
+++ b/dom/xslt/xslt/txXPathResultComparator.h
@@ -0,0 +1,92 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef TRANSFRMX_XPATHRESULTCOMPARATOR_H
+#define TRANSFRMX_XPATHRESULTCOMPARATOR_H
+
+#include "mozilla/Attributes.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/intl/Collator.h"
+#include "mozilla/UniquePtr.h"
+#include "txCore.h"
+#include "nsCOMPtr.h"
+#include "nsString.h"
+
+class Expr;
+class txIEvalContext;
+
+/*
+ * Result comparators
+ */
+class txXPathResultComparator {
+ public:
+ virtual ~txXPathResultComparator() = default;
+
+ /*
+ * Compares two XPath results. Returns -1 if val1 < val2,
+ * 1 if val1 > val2 and 0 if val1 == val2.
+ */
+ virtual int compareValues(txObject* val1, txObject* val2) = 0;
+
+ /*
+ * Create a sortable value.
+ */
+ virtual nsresult createSortableValue(Expr* aExpr, txIEvalContext* aContext,
+ txObject*& aResult) = 0;
+};
+
+/*
+ * Compare results as stings (data-type="text")
+ */
+class txResultStringComparator : public txXPathResultComparator {
+ public:
+ txResultStringComparator(bool aAscending, bool aUpperFirst,
+ const nsString& aLanguage);
+
+ int compareValues(txObject* aVal1, txObject* aVal2) override;
+ nsresult createSortableValue(Expr* aExpr, txIEvalContext* aContext,
+ txObject*& aResult) override;
+
+ private:
+ mozilla::UniquePtr<const mozilla::intl::Collator> mCollator;
+ nsresult init(const nsString& aLanguage);
+ int mSorting;
+
+ class StringValue : public txObject {
+ public:
+ StringValue();
+ ~StringValue();
+
+ nsresult initCaseKey(const mozilla::intl::Collator& aCollator);
+
+ nsTArray<uint8_t> mKey;
+ // Either mCaseKeyString is non-null, or we have a usable key in mCaseKey
+ // already.
+ mozilla::UniquePtr<nsString> mCaseKeyString;
+ nsTArray<uint8_t> mCaseKey;
+ };
+};
+
+/*
+ * Compare results as numbers (data-type="number")
+ */
+class txResultNumberComparator : public txXPathResultComparator {
+ public:
+ explicit txResultNumberComparator(bool aAscending);
+
+ int compareValues(txObject* aVal1, txObject* aVal2) override;
+ nsresult createSortableValue(Expr* aExpr, txIEvalContext* aContext,
+ txObject*& aResult) override;
+
+ private:
+ int mAscending;
+
+ class NumberValue : public txObject {
+ public:
+ double mVal;
+ };
+};
+
+#endif
diff --git a/dom/xslt/xslt/txXSLTEnvironmentFunctionCall.cpp b/dom/xslt/xslt/txXSLTEnvironmentFunctionCall.cpp
new file mode 100644
index 0000000000..02068f2b35
--- /dev/null
+++ b/dom/xslt/xslt/txXSLTEnvironmentFunctionCall.cpp
@@ -0,0 +1,124 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txIXPathContext.h"
+#include "nsGkAtoms.h"
+#include "nsError.h"
+#include "txXMLUtils.h"
+#include "txXSLTFunctions.h"
+#include "txExpandedName.h"
+#include "txNamespaceMap.h"
+
+nsresult txXSLTEnvironmentFunctionCall::evaluate(txIEvalContext* aContext,
+ txAExprResult** aResult) {
+ *aResult = nullptr;
+
+ if (!requireParams(1, 1, aContext)) {
+ return NS_ERROR_XPATH_BAD_ARGUMENT_COUNT;
+ }
+
+ nsAutoString property;
+ nsresult rv = mParams[0]->evaluateToString(aContext, property);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ txExpandedName qname;
+ rv = qname.init(property, mMappings, mType != FUNCTION_AVAILABLE);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ switch (mType) {
+ case SYSTEM_PROPERTY: {
+ if (qname.mNamespaceID == kNameSpaceID_XSLT) {
+ if (qname.mLocalName == nsGkAtoms::version) {
+ return aContext->recycler()->getNumberResult(1.0, aResult);
+ }
+ if (qname.mLocalName == nsGkAtoms::vendor) {
+ return aContext->recycler()->getStringResult(u"Transformiix"_ns,
+ aResult);
+ }
+ if (qname.mLocalName == nsGkAtoms::vendorUrl) {
+ return aContext->recycler()->getStringResult(
+ u"http://www.mozilla.org/projects/xslt/"_ns, aResult);
+ }
+ }
+ aContext->recycler()->getEmptyStringResult(aResult);
+ break;
+ }
+ case ELEMENT_AVAILABLE: {
+ bool val = qname.mNamespaceID == kNameSpaceID_XSLT &&
+ (qname.mLocalName == nsGkAtoms::applyImports ||
+ qname.mLocalName == nsGkAtoms::applyTemplates ||
+ qname.mLocalName == nsGkAtoms::attribute ||
+ qname.mLocalName == nsGkAtoms::attributeSet ||
+ qname.mLocalName == nsGkAtoms::callTemplate ||
+ qname.mLocalName == nsGkAtoms::choose ||
+ qname.mLocalName == nsGkAtoms::comment ||
+ qname.mLocalName == nsGkAtoms::copy ||
+ qname.mLocalName == nsGkAtoms::copyOf ||
+ qname.mLocalName == nsGkAtoms::decimalFormat ||
+ qname.mLocalName == nsGkAtoms::element ||
+ qname.mLocalName == nsGkAtoms::fallback ||
+ qname.mLocalName == nsGkAtoms::forEach ||
+ qname.mLocalName == nsGkAtoms::_if ||
+ qname.mLocalName == nsGkAtoms::import ||
+ qname.mLocalName == nsGkAtoms::include ||
+ qname.mLocalName == nsGkAtoms::key ||
+ qname.mLocalName == nsGkAtoms::message ||
+ // qname.mLocalName == nsGkAtoms::namespaceAlias ||
+ qname.mLocalName == nsGkAtoms::number ||
+ qname.mLocalName == nsGkAtoms::otherwise ||
+ qname.mLocalName == nsGkAtoms::output ||
+ qname.mLocalName == nsGkAtoms::param ||
+ qname.mLocalName == nsGkAtoms::preserveSpace ||
+ qname.mLocalName == nsGkAtoms::processingInstruction ||
+ qname.mLocalName == nsGkAtoms::sort ||
+ qname.mLocalName == nsGkAtoms::stripSpace ||
+ qname.mLocalName == nsGkAtoms::stylesheet ||
+ qname.mLocalName == nsGkAtoms::_template ||
+ qname.mLocalName == nsGkAtoms::text ||
+ qname.mLocalName == nsGkAtoms::transform ||
+ qname.mLocalName == nsGkAtoms::valueOf ||
+ qname.mLocalName == nsGkAtoms::variable ||
+ qname.mLocalName == nsGkAtoms::when ||
+ qname.mLocalName == nsGkAtoms::withParam);
+
+ aContext->recycler()->getBoolResult(val, aResult);
+ break;
+ }
+ case FUNCTION_AVAILABLE: {
+ extern bool TX_XSLTFunctionAvailable(nsAtom * aName,
+ int32_t aNameSpaceID);
+
+ txCoreFunctionCall::eType type;
+ bool val =
+ (qname.mNamespaceID == kNameSpaceID_None &&
+ txCoreFunctionCall::getTypeFromAtom(qname.mLocalName, type)) ||
+ TX_XSLTFunctionAvailable(qname.mLocalName, qname.mNamespaceID);
+
+ aContext->recycler()->getBoolResult(val, aResult);
+ break;
+ }
+ }
+
+ return NS_OK;
+}
+
+Expr::ResultType txXSLTEnvironmentFunctionCall::getReturnType() {
+ return mType == SYSTEM_PROPERTY ? (STRING_RESULT | NUMBER_RESULT)
+ : BOOLEAN_RESULT;
+}
+
+bool txXSLTEnvironmentFunctionCall::isSensitiveTo(ContextSensitivity aContext) {
+ return argsSensitiveTo(aContext);
+}
+
+#ifdef TX_TO_STRING
+void txXSLTEnvironmentFunctionCall::appendName(nsAString& aDest) {
+ nsStaticAtom* atom = mType == SYSTEM_PROPERTY ? nsGkAtoms::systemProperty
+ : mType == ELEMENT_AVAILABLE
+ ? nsGkAtoms::elementAvailable
+ : nsGkAtoms::functionAvailable;
+ aDest.Append(atom->GetUTF16String());
+}
+#endif
diff --git a/dom/xslt/xslt/txXSLTFunctions.h b/dom/xslt/xslt/txXSLTFunctions.h
new file mode 100644
index 0000000000..4b7401eb83
--- /dev/null
+++ b/dom/xslt/xslt/txXSLTFunctions.h
@@ -0,0 +1,149 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef TRANSFRMX_XSLT_FUNCTIONS_H
+#define TRANSFRMX_XSLT_FUNCTIONS_H
+
+#include "mozilla/UniquePtr.h"
+#include "txExpr.h"
+#include "txXMLUtils.h"
+#include "txNamespaceMap.h"
+
+class txStylesheet;
+
+/**
+ * The definition for the XSLT document() function
+ **/
+class DocumentFunctionCall : public FunctionCall {
+ public:
+ /**
+ * Creates a new document() function call
+ **/
+ explicit DocumentFunctionCall(const nsAString& aBaseURI);
+
+ TX_DECL_FUNCTION
+
+ private:
+ nsString mBaseURI;
+};
+
+/*
+ * The definition for the XSLT key() function
+ */
+class txKeyFunctionCall : public FunctionCall {
+ public:
+ /*
+ * Creates a new key() function call
+ */
+ explicit txKeyFunctionCall(txNamespaceMap* aMappings);
+
+ TX_DECL_FUNCTION
+
+ private:
+ RefPtr<txNamespaceMap> mMappings;
+};
+
+/**
+ * The definition for the XSLT format-number() function
+ **/
+class txFormatNumberFunctionCall : public FunctionCall {
+ public:
+ /**
+ * Creates a new format-number() function call
+ **/
+ txFormatNumberFunctionCall(txStylesheet* aStylesheet,
+ txNamespaceMap* aMappings);
+
+ TX_DECL_FUNCTION
+
+ private:
+ static const char16_t FORMAT_QUOTE;
+
+ enum FormatParseState {
+ Prefix,
+ IntDigit,
+ IntZero,
+ FracZero,
+ FracDigit,
+ Suffix,
+ Finished
+ };
+
+ // Helper that reports and invalid arg to the provided context.
+ void ReportInvalidArg(txIEvalContext* aContext);
+
+ txStylesheet* mStylesheet;
+ RefPtr<txNamespaceMap> mMappings;
+};
+
+/**
+ * DecimalFormat
+ * A representation of the XSLT element <xsl:decimal-format>
+ */
+class txDecimalFormat {
+ public:
+ /*
+ * Creates a new decimal format and initilizes all properties with
+ * default values
+ */
+ txDecimalFormat();
+ bool isEqual(txDecimalFormat* other);
+
+ char16_t mDecimalSeparator;
+ char16_t mGroupingSeparator;
+ nsString mInfinity;
+ char16_t mMinusSign;
+ nsString mNaN;
+ char16_t mPercent;
+ char16_t mPerMille;
+ char16_t mZeroDigit;
+ char16_t mDigit;
+ char16_t mPatternSeparator;
+};
+
+/**
+ * The definition for the XSLT current() function
+ **/
+class CurrentFunctionCall : public FunctionCall {
+ public:
+ /**
+ * Creates a new current() function call
+ **/
+ CurrentFunctionCall();
+
+ TX_DECL_FUNCTION
+};
+
+/**
+ * The definition for the XSLT generate-id() function
+ **/
+class GenerateIdFunctionCall : public FunctionCall {
+ public:
+ /**
+ * Creates a new generate-id() function call
+ **/
+ GenerateIdFunctionCall();
+
+ TX_DECL_FUNCTION
+};
+
+/**
+ * A system-property(), element-available() or function-available() function.
+ */
+class txXSLTEnvironmentFunctionCall : public FunctionCall {
+ public:
+ enum eType { SYSTEM_PROPERTY, ELEMENT_AVAILABLE, FUNCTION_AVAILABLE };
+
+ txXSLTEnvironmentFunctionCall(eType aType, txNamespaceMap* aMappings)
+ : mType(aType), mMappings(aMappings) {}
+
+ TX_DECL_FUNCTION
+
+ private:
+ eType mType;
+ RefPtr<txNamespaceMap> mMappings; // Used to resolve prefixes
+};
+
+#endif
diff --git a/dom/xslt/xslt/txXSLTMsgsURL.h b/dom/xslt/xslt/txXSLTMsgsURL.h
new file mode 100644
index 0000000000..321b59548a
--- /dev/null
+++ b/dom/xslt/xslt/txXSLTMsgsURL.h
@@ -0,0 +1,11 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef DOM_XSLT_XSLT_TXXSLTMSGSURL_H_
+#define DOM_XSLT_XSLT_TXXSLTMSGSURL_H_
+
+#define XSLT_MSGS_URL "chrome://global/locale/xslt/xslt.properties"
+
+#endif // DOM_XSLT_XSLT_TXXSLTMSGSURL_H_
diff --git a/dom/xslt/xslt/txXSLTNumber.cpp b/dom/xslt/xslt/txXSLTNumber.cpp
new file mode 100644
index 0000000000..9ae449f27f
--- /dev/null
+++ b/dom/xslt/xslt/txXSLTNumber.cpp
@@ -0,0 +1,741 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/FloatingPoint.h"
+
+#include "txXSLTNumber.h"
+#include "nsGkAtoms.h"
+#include "txCore.h"
+#include <math.h>
+#include "txExpr.h"
+#include "txXSLTPatterns.h"
+#include "txIXPathContext.h"
+#include "txXPathTreeWalker.h"
+
+#include <algorithm>
+
+using mozilla::MakeUnique;
+using mozilla::UniquePtr;
+
+nsresult txXSLTNumber::createNumber(Expr* aValueExpr, txPattern* aCountPattern,
+ txPattern* aFromPattern, LevelType aLevel,
+ Expr* aGroupSize, Expr* aGroupSeparator,
+ Expr* aFormat, txIEvalContext* aContext,
+ nsAString& aResult) {
+ aResult.Truncate();
+ nsresult rv = NS_OK;
+
+ // Parse format
+ txList counters;
+ nsAutoString head, tail;
+ rv = getCounters(aGroupSize, aGroupSeparator, aFormat, aContext, counters,
+ head, tail);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // Create list of values to format
+ txList values;
+ nsAutoString valueString;
+ rv = getValueList(aValueExpr, aCountPattern, aFromPattern, aLevel, aContext,
+ values, valueString);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (!valueString.IsEmpty()) {
+ aResult = valueString;
+
+ return NS_OK;
+ }
+
+ // Create resulting string
+ aResult = head;
+ bool first = true;
+ txListIterator valueIter(&values);
+ txListIterator counterIter(&counters);
+ valueIter.resetToEnd();
+ int32_t value;
+ txFormattedCounter* counter = 0;
+ while ((value = NS_PTR_TO_INT32(valueIter.previous()))) {
+ if (counterIter.hasNext()) {
+ counter = (txFormattedCounter*)counterIter.next();
+ }
+
+ if (!first) {
+ aResult.Append(counter->mSeparator);
+ }
+
+ counter->appendNumber(value, aResult);
+ first = false;
+ }
+
+ aResult.Append(tail);
+
+ txListIterator iter(&counters);
+ while (iter.hasNext()) {
+ delete (txFormattedCounter*)iter.next();
+ }
+
+ return NS_OK;
+}
+
+nsresult txXSLTNumber::getValueList(Expr* aValueExpr, txPattern* aCountPattern,
+ txPattern* aFromPattern, LevelType aLevel,
+ txIEvalContext* aContext, txList& aValues,
+ nsAString& aValueString) {
+ aValueString.Truncate();
+ nsresult rv = NS_OK;
+
+ // If the value attribute exists then use that
+ if (aValueExpr) {
+ RefPtr<txAExprResult> result;
+ rv = aValueExpr->evaluate(aContext, getter_AddRefs(result));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ double value = result->numberValue();
+
+ if (std::isinf(value) || std::isnan(value) || value < 0.5) {
+ txDouble::toString(value, aValueString);
+ return NS_OK;
+ }
+
+ aValues.add(NS_INT32_TO_PTR((int32_t)floor(value + 0.5)));
+ return NS_OK;
+ }
+
+ // Otherwise use count/from/level
+
+ txPattern* countPattern = aCountPattern;
+ UniquePtr<txPattern> newCountPattern;
+ const txXPathNode& currNode = aContext->getContextNode();
+
+ // Parse count- and from-attributes
+
+ if (!aCountPattern) {
+ txNodeTest* nodeTest;
+ uint16_t nodeType = txXPathNodeUtils::getNodeType(currNode);
+ switch (nodeType) {
+ case txXPathNodeType::ELEMENT_NODE: {
+ RefPtr<nsAtom> localName = txXPathNodeUtils::getLocalName(currNode);
+ int32_t namespaceID = txXPathNodeUtils::getNamespaceID(currNode);
+ nodeTest = new txNameTest(0, localName, namespaceID,
+ txXPathNodeType::ELEMENT_NODE);
+ break;
+ }
+ case txXPathNodeType::TEXT_NODE:
+ case txXPathNodeType::CDATA_SECTION_NODE: {
+ nodeTest = new txNodeTypeTest(txNodeTypeTest::TEXT_TYPE);
+ break;
+ }
+ case txXPathNodeType::PROCESSING_INSTRUCTION_NODE: {
+ txNodeTypeTest* typeTest;
+ typeTest = new txNodeTypeTest(txNodeTypeTest::PI_TYPE);
+ nsAutoString nodeName;
+ txXPathNodeUtils::getNodeName(currNode, nodeName);
+ typeTest->setNodeName(nodeName);
+ nodeTest = typeTest;
+ break;
+ }
+ case txXPathNodeType::COMMENT_NODE: {
+ nodeTest = new txNodeTypeTest(txNodeTypeTest::COMMENT_TYPE);
+ break;
+ }
+ case txXPathNodeType::DOCUMENT_NODE:
+ case txXPathNodeType::ATTRIBUTE_NODE:
+ default: {
+ // this won't match anything as we walk up the tree
+ // but it's what the spec says to do
+ nodeTest = new txNameTest(0, nsGkAtoms::_asterisk, 0, nodeType);
+ break;
+ }
+ }
+ MOZ_ASSERT(nodeTest);
+ newCountPattern = MakeUnique<txStepPattern>(nodeTest, false);
+ countPattern = newCountPattern.get();
+ }
+
+ // Generate list of values depending on the value of the level-attribute
+
+ // level = "single"
+ if (aLevel == eLevelSingle) {
+ txXPathTreeWalker walker(currNode);
+ do {
+ if (aFromPattern && !walker.isOnNode(currNode)) {
+ bool matched;
+ rv = aFromPattern->matches(walker.getCurrentPosition(), aContext,
+ matched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (matched) {
+ break;
+ }
+ }
+
+ bool matched;
+ rv =
+ countPattern->matches(walker.getCurrentPosition(), aContext, matched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (matched) {
+ int32_t count;
+ rv = getSiblingCount(walker, countPattern, aContext, &count);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aValues.add(NS_INT32_TO_PTR(count));
+ break;
+ }
+
+ } while (walker.moveToParent());
+
+ // Spec says to only match ancestors that are decendants of the
+ // ancestor that matches the from-pattern, so keep going to make
+ // sure that there is an ancestor that does.
+ if (aFromPattern && aValues.getLength()) {
+ bool hasParent;
+ while ((hasParent = walker.moveToParent())) {
+ bool matched;
+ rv = aFromPattern->matches(walker.getCurrentPosition(), aContext,
+ matched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (matched) {
+ break;
+ }
+ }
+
+ if (!hasParent) {
+ aValues.clear();
+ }
+ }
+ }
+ // level = "multiple"
+ else if (aLevel == eLevelMultiple) {
+ // find all ancestor-or-selfs that matches count until...
+ txXPathTreeWalker walker(currNode);
+ bool matchedFrom = false;
+ do {
+ if (aFromPattern && !walker.isOnNode(currNode)) {
+ rv = aFromPattern->matches(walker.getCurrentPosition(), aContext,
+ matchedFrom);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (matchedFrom) {
+ //... we find one that matches from
+ break;
+ }
+ }
+
+ bool matched;
+ rv =
+ countPattern->matches(walker.getCurrentPosition(), aContext, matched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (matched) {
+ int32_t count;
+ rv = getSiblingCount(walker, countPattern, aContext, &count);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aValues.add(NS_INT32_TO_PTR(count));
+ }
+ } while (walker.moveToParent());
+
+ // Spec says to only match ancestors that are decendants of the
+ // ancestor that matches the from-pattern, so if none did then
+ // we shouldn't search anything
+ if (aFromPattern && !matchedFrom) {
+ aValues.clear();
+ }
+ }
+ // level = "any"
+ else if (aLevel == eLevelAny) {
+ int32_t value = 0;
+ bool matchedFrom = false;
+
+ txXPathTreeWalker walker(currNode);
+ do {
+ if (aFromPattern && !walker.isOnNode(currNode)) {
+ rv = aFromPattern->matches(walker.getCurrentPosition(), aContext,
+ matchedFrom);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (matchedFrom) {
+ break;
+ }
+ }
+
+ bool matched;
+ rv =
+ countPattern->matches(walker.getCurrentPosition(), aContext, matched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (matched) {
+ ++value;
+ }
+
+ } while (getPrevInDocumentOrder(walker));
+
+ // Spec says to only count nodes that follows the first node that
+ // matches the from pattern. So so if none did then we shouldn't
+ // count any
+ if (aFromPattern && !matchedFrom) {
+ value = 0;
+ }
+
+ if (value) {
+ aValues.add(NS_INT32_TO_PTR(value));
+ }
+ }
+
+ return NS_OK;
+}
+
+nsresult txXSLTNumber::getCounters(Expr* aGroupSize, Expr* aGroupSeparator,
+ Expr* aFormat, txIEvalContext* aContext,
+ txList& aCounters, nsAString& aHead,
+ nsAString& aTail) {
+ aHead.Truncate();
+ aTail.Truncate();
+
+ nsresult rv = NS_OK;
+
+ nsAutoString groupSeparator;
+ int32_t groupSize = 0;
+ if (aGroupSize && aGroupSeparator) {
+ nsAutoString sizeStr;
+ rv = aGroupSize->evaluateToString(aContext, sizeStr);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ double size = txDouble::toDouble(sizeStr);
+ groupSize = (int32_t)size;
+ if ((double)groupSize != size) {
+ groupSize = 0;
+ }
+
+ rv = aGroupSeparator->evaluateToString(aContext, groupSeparator);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ nsAutoString format;
+ if (aFormat) {
+ rv = aFormat->evaluateToString(aContext, format);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ uint32_t formatLen = format.Length();
+ uint32_t formatPos = 0;
+ char16_t ch = 0;
+
+ // start with header
+ while (formatPos < formatLen &&
+ !isAlphaNumeric(ch = format.CharAt(formatPos))) {
+ aHead.Append(ch);
+ ++formatPos;
+ }
+
+ // If there are no formatting tokens we need to create a default one.
+ if (formatPos == formatLen) {
+ txFormattedCounter* defaultCounter;
+ rv = txFormattedCounter::getCounterFor(u"1"_ns, groupSize, groupSeparator,
+ defaultCounter);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ defaultCounter->mSeparator.Assign('.');
+ aCounters.add(defaultCounter);
+
+ return NS_OK;
+ }
+
+ while (formatPos < formatLen) {
+ nsAutoString sepToken;
+ // parse separator token
+ if (!aCounters.getLength()) {
+ // Set the first counters separator to default value so that if
+ // there is only one formatting token and we're formatting a
+ // value-list longer then one we use the default separator. This
+ // won't be used when formatting the first value anyway.
+ sepToken.Assign('.');
+ } else {
+ while (formatPos < formatLen &&
+ !isAlphaNumeric(ch = format.CharAt(formatPos))) {
+ sepToken.Append(ch);
+ ++formatPos;
+ }
+ }
+
+ // if we're at the end of the string then the previous token was the tail
+ if (formatPos == formatLen) {
+ aTail = sepToken;
+ return NS_OK;
+ }
+
+ // parse formatting token
+ nsAutoString numToken;
+ while (formatPos < formatLen &&
+ isAlphaNumeric(ch = format.CharAt(formatPos))) {
+ numToken.Append(ch);
+ ++formatPos;
+ }
+
+ txFormattedCounter* counter = 0;
+ rv = txFormattedCounter::getCounterFor(numToken, groupSize, groupSeparator,
+ counter);
+ if (NS_FAILED(rv)) {
+ txListIterator iter(&aCounters);
+ while (iter.hasNext()) {
+ delete (txFormattedCounter*)iter.next();
+ }
+ aCounters.clear();
+ return rv;
+ }
+
+ // Add to list of counters
+ counter->mSeparator = sepToken;
+ aCounters.add(counter);
+ }
+
+ return NS_OK;
+}
+
+nsresult txXSLTNumber::getSiblingCount(txXPathTreeWalker& aWalker,
+ txPattern* aCountPattern,
+ txIMatchContext* aContext,
+ int32_t* aCount) {
+ int32_t value = 1;
+ while (aWalker.moveToPreviousSibling()) {
+ bool matched;
+ nsresult rv =
+ aCountPattern->matches(aWalker.getCurrentPosition(), aContext, matched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (matched) {
+ ++value;
+ }
+ }
+
+ *aCount = value;
+
+ return NS_OK;
+}
+
+bool txXSLTNumber::getPrevInDocumentOrder(txXPathTreeWalker& aWalker) {
+ if (aWalker.moveToPreviousSibling()) {
+ while (aWalker.moveToLastChild()) {
+ // do nothing
+ }
+ return true;
+ }
+ return aWalker.moveToParent();
+}
+
+struct CharRange {
+ char16_t lower; // inclusive
+ char16_t upper; // inclusive
+
+ bool operator<(const CharRange& other) const { return upper < other.lower; }
+};
+
+bool txXSLTNumber::isAlphaNumeric(char16_t ch) {
+ static const CharRange alphanumericRanges[] = {
+ // clang-format off
+ { 0x0030, 0x0039 },
+ { 0x0041, 0x005A },
+ { 0x0061, 0x007A },
+ { 0x00AA, 0x00AA },
+ { 0x00B2, 0x00B3 },
+ { 0x00B5, 0x00B5 },
+ { 0x00B9, 0x00BA },
+ { 0x00BC, 0x00BE },
+ { 0x00C0, 0x00D6 },
+ { 0x00D8, 0x00F6 },
+ { 0x00F8, 0x021F },
+ { 0x0222, 0x0233 },
+ { 0x0250, 0x02AD },
+ { 0x02B0, 0x02B8 },
+ { 0x02BB, 0x02C1 },
+ { 0x02D0, 0x02D1 },
+ { 0x02E0, 0x02E4 },
+ { 0x02EE, 0x02EE },
+ { 0x037A, 0x037A },
+ { 0x0386, 0x0386 },
+ { 0x0388, 0x038A },
+ { 0x038C, 0x038C },
+ { 0x038E, 0x03A1 },
+ { 0x03A3, 0x03CE },
+ { 0x03D0, 0x03D7 },
+ { 0x03DA, 0x03F3 },
+ { 0x0400, 0x0481 },
+ { 0x048C, 0x04C4 },
+ { 0x04C7, 0x04C8 },
+ { 0x04CB, 0x04CC },
+ { 0x04D0, 0x04F5 },
+ { 0x04F8, 0x04F9 },
+ { 0x0531, 0x0556 },
+ { 0x0559, 0x0559 },
+ { 0x0561, 0x0587 },
+ { 0x05D0, 0x05EA },
+ { 0x05F0, 0x05F2 },
+ { 0x0621, 0x063A },
+ { 0x0640, 0x064A },
+ { 0x0660, 0x0669 },
+ { 0x0671, 0x06D3 },
+ { 0x06D5, 0x06D5 },
+ { 0x06E5, 0x06E6 },
+ { 0x06F0, 0x06FC },
+ { 0x0710, 0x0710 },
+ { 0x0712, 0x072C },
+ { 0x0780, 0x07A5 },
+ { 0x0905, 0x0939 },
+ { 0x093D, 0x093D },
+ { 0x0950, 0x0950 },
+ { 0x0958, 0x0961 },
+ { 0x0966, 0x096F },
+ { 0x0985, 0x098C },
+ { 0x098F, 0x0990 },
+ { 0x0993, 0x09A8 },
+ { 0x09AA, 0x09B0 },
+ { 0x09B2, 0x09B2 },
+ { 0x09B6, 0x09B9 },
+ { 0x09DC, 0x09DD },
+ { 0x09DF, 0x09E1 },
+ { 0x09E6, 0x09F1 },
+ { 0x09F4, 0x09F9 },
+ { 0x0A05, 0x0A0A },
+ { 0x0A0F, 0x0A10 },
+ { 0x0A13, 0x0A28 },
+ { 0x0A2A, 0x0A30 },
+ { 0x0A32, 0x0A33 },
+ { 0x0A35, 0x0A36 },
+ { 0x0A38, 0x0A39 },
+ { 0x0A59, 0x0A5C },
+ { 0x0A5E, 0x0A5E },
+ { 0x0A66, 0x0A6F },
+ { 0x0A72, 0x0A74 },
+ { 0x0A85, 0x0A8B },
+ { 0x0A8D, 0x0A8D },
+ { 0x0A8F, 0x0A91 },
+ { 0x0A93, 0x0AA8 },
+ { 0x0AAA, 0x0AB0 },
+ { 0x0AB2, 0x0AB3 },
+ { 0x0AB5, 0x0AB9 },
+ { 0x0ABD, 0x0ABD },
+ { 0x0AD0, 0x0AD0 },
+ { 0x0AE0, 0x0AE0 },
+ { 0x0AE6, 0x0AEF },
+ { 0x0B05, 0x0B0C },
+ { 0x0B0F, 0x0B10 },
+ { 0x0B13, 0x0B28 },
+ { 0x0B2A, 0x0B30 },
+ { 0x0B32, 0x0B33 },
+ { 0x0B36, 0x0B39 },
+ { 0x0B3D, 0x0B3D },
+ { 0x0B5C, 0x0B5D },
+ { 0x0B5F, 0x0B61 },
+ { 0x0B66, 0x0B6F },
+ { 0x0B85, 0x0B8A },
+ { 0x0B8E, 0x0B90 },
+ { 0x0B92, 0x0B95 },
+ { 0x0B99, 0x0B9A },
+ { 0x0B9C, 0x0B9C },
+ { 0x0B9E, 0x0B9F },
+ { 0x0BA3, 0x0BA4 },
+ { 0x0BA8, 0x0BAA },
+ { 0x0BAE, 0x0BB5 },
+ { 0x0BB7, 0x0BB9 },
+ { 0x0BE7, 0x0BF2 },
+ { 0x0C05, 0x0C0C },
+ { 0x0C0E, 0x0C10 },
+ { 0x0C12, 0x0C28 },
+ { 0x0C2A, 0x0C33 },
+ { 0x0C35, 0x0C39 },
+ { 0x0C60, 0x0C61 },
+ { 0x0C66, 0x0C6F },
+ { 0x0C85, 0x0C8C },
+ { 0x0C8E, 0x0C90 },
+ { 0x0C92, 0x0CA8 },
+ { 0x0CAA, 0x0CB3 },
+ { 0x0CB5, 0x0CB9 },
+ { 0x0CDE, 0x0CDE },
+ { 0x0CE0, 0x0CE1 },
+ { 0x0CE6, 0x0CEF },
+ { 0x0D05, 0x0D0C },
+ { 0x0D0E, 0x0D10 },
+ { 0x0D12, 0x0D28 },
+ { 0x0D2A, 0x0D39 },
+ { 0x0D60, 0x0D61 },
+ { 0x0D66, 0x0D6F },
+ { 0x0D85, 0x0D96 },
+ { 0x0D9A, 0x0DB1 },
+ { 0x0DB3, 0x0DBB },
+ { 0x0DBD, 0x0DBD },
+ { 0x0DC0, 0x0DC6 },
+ { 0x0E01, 0x0E30 },
+ { 0x0E32, 0x0E33 },
+ { 0x0E40, 0x0E46 },
+ { 0x0E50, 0x0E59 },
+ { 0x0E81, 0x0E82 },
+ { 0x0E84, 0x0E84 },
+ { 0x0E87, 0x0E88 },
+ { 0x0E8A, 0x0E8A },
+ { 0x0E8D, 0x0E8D },
+ { 0x0E94, 0x0E97 },
+ { 0x0E99, 0x0E9F },
+ { 0x0EA1, 0x0EA3 },
+ { 0x0EA5, 0x0EA5 },
+ { 0x0EA7, 0x0EA7 },
+ { 0x0EAA, 0x0EAB },
+ { 0x0EAD, 0x0EB0 },
+ { 0x0EB2, 0x0EB3 },
+ { 0x0EBD, 0x0EBD },
+ { 0x0EC0, 0x0EC4 },
+ { 0x0EC6, 0x0EC6 },
+ { 0x0ED0, 0x0ED9 },
+ { 0x0EDC, 0x0EDD },
+ { 0x0F00, 0x0F00 },
+ { 0x0F20, 0x0F33 },
+ { 0x0F40, 0x0F47 },
+ { 0x0F49, 0x0F6A },
+ { 0x0F88, 0x0F8B },
+ { 0x1000, 0x1021 },
+ { 0x1023, 0x1027 },
+ { 0x1029, 0x102A },
+ { 0x1040, 0x1049 },
+ { 0x1050, 0x1055 },
+ { 0x10A0, 0x10C5 },
+ { 0x10D0, 0x10F6 },
+ { 0x1100, 0x1159 },
+ { 0x115F, 0x11A2 },
+ { 0x11A8, 0x11F9 },
+ { 0x1200, 0x1206 },
+ { 0x1208, 0x1246 },
+ { 0x1248, 0x1248 },
+ { 0x124A, 0x124D },
+ { 0x1250, 0x1256 },
+ { 0x1258, 0x1258 },
+ { 0x125A, 0x125D },
+ { 0x1260, 0x1286 },
+ { 0x1288, 0x1288 },
+ { 0x128A, 0x128D },
+ { 0x1290, 0x12AE },
+ { 0x12B0, 0x12B0 },
+ { 0x12B2, 0x12B5 },
+ { 0x12B8, 0x12BE },
+ { 0x12C0, 0x12C0 },
+ { 0x12C2, 0x12C5 },
+ { 0x12C8, 0x12CE },
+ { 0x12D0, 0x12D6 },
+ { 0x12D8, 0x12EE },
+ { 0x12F0, 0x130E },
+ { 0x1310, 0x1310 },
+ { 0x1312, 0x1315 },
+ { 0x1318, 0x131E },
+ { 0x1320, 0x1346 },
+ { 0x1348, 0x135A },
+ { 0x1369, 0x137C },
+ { 0x13A0, 0x13F4 },
+ { 0x1401, 0x166C },
+ { 0x166F, 0x1676 },
+ { 0x1681, 0x169A },
+ { 0x16A0, 0x16EA },
+ { 0x16EE, 0x16F0 },
+ { 0x1780, 0x17B3 },
+ { 0x17E0, 0x17E9 },
+ { 0x1810, 0x1819 },
+ { 0x1820, 0x1877 },
+ { 0x1880, 0x18A8 },
+ { 0x1E00, 0x1E9B },
+ { 0x1EA0, 0x1EF9 },
+ { 0x1F00, 0x1F15 },
+ { 0x1F18, 0x1F1D },
+ { 0x1F20, 0x1F45 },
+ { 0x1F48, 0x1F4D },
+ { 0x1F50, 0x1F57 },
+ { 0x1F59, 0x1F59 },
+ { 0x1F5B, 0x1F5B },
+ { 0x1F5D, 0x1F5D },
+ { 0x1F5F, 0x1F7D },
+ { 0x1F80, 0x1FB4 },
+ { 0x1FB6, 0x1FBC },
+ { 0x1FBE, 0x1FBE },
+ { 0x1FC2, 0x1FC4 },
+ { 0x1FC6, 0x1FCC },
+ { 0x1FD0, 0x1FD3 },
+ { 0x1FD6, 0x1FDB },
+ { 0x1FE0, 0x1FEC },
+ { 0x1FF2, 0x1FF4 },
+ { 0x1FF6, 0x1FFC },
+ { 0x2070, 0x2070 },
+ { 0x2074, 0x2079 },
+ { 0x207F, 0x2089 },
+ { 0x2102, 0x2102 },
+ { 0x2107, 0x2107 },
+ { 0x210A, 0x2113 },
+ { 0x2115, 0x2115 },
+ { 0x2119, 0x211D },
+ { 0x2124, 0x2124 },
+ { 0x2126, 0x2126 },
+ { 0x2128, 0x2128 },
+ { 0x212A, 0x212D },
+ { 0x212F, 0x2131 },
+ { 0x2133, 0x2139 },
+ { 0x2153, 0x2183 },
+ { 0x2460, 0x249B },
+ { 0x24EA, 0x24EA },
+ { 0x2776, 0x2793 },
+ { 0x3005, 0x3007 },
+ { 0x3021, 0x3029 },
+ { 0x3031, 0x3035 },
+ { 0x3038, 0x303A },
+ { 0x3041, 0x3094 },
+ { 0x309D, 0x309E },
+ { 0x30A1, 0x30FA },
+ { 0x30FC, 0x30FE },
+ { 0x3105, 0x312C },
+ { 0x3131, 0x318E },
+ { 0x3192, 0x3195 },
+ { 0x31A0, 0x31B7 },
+ { 0x3220, 0x3229 },
+ { 0x3280, 0x3289 },
+ { 0x3400, 0x3400 },
+ { 0x4DB5, 0x4DB5 },
+ { 0x4E00, 0x4E00 },
+ { 0x9FA5, 0x9FA5 },
+ { 0xA000, 0xA48C },
+ { 0xAC00, 0xAC00 },
+ { 0xD7A3, 0xD7A3 },
+ { 0xF900, 0xFA2D },
+ { 0xFB00, 0xFB06 },
+ { 0xFB13, 0xFB17 },
+ { 0xFB1D, 0xFB1D },
+ { 0xFB1F, 0xFB28 },
+ { 0xFB2A, 0xFB36 },
+ { 0xFB38, 0xFB3C },
+ { 0xFB3E, 0xFB3E },
+ { 0xFB40, 0xFB41 },
+ { 0xFB43, 0xFB44 },
+ { 0xFB46, 0xFBB1 },
+ { 0xFBD3, 0xFD3D },
+ { 0xFD50, 0xFD8F },
+ { 0xFD92, 0xFDC7 },
+ { 0xFDF0, 0xFDFB },
+ { 0xFE70, 0xFE72 },
+ { 0xFE74, 0xFE74 },
+ { 0xFE76, 0xFEFC },
+ { 0xFF10, 0xFF19 },
+ { 0xFF21, 0xFF3A },
+ { 0xFF41, 0xFF5A },
+ { 0xFF66, 0xFFBE },
+ { 0xFFC2, 0xFFC7 },
+ { 0xFFCA, 0xFFCF },
+ { 0xFFD2, 0xFFD7 }
+ // clang-format on
+ };
+
+ CharRange search = {ch, ch};
+ const CharRange* end = mozilla::ArrayEnd(alphanumericRanges);
+ const CharRange* element =
+ std::lower_bound(&alphanumericRanges[0], end, search);
+ if (element == end) {
+ return false;
+ }
+ return element->lower <= ch && ch <= element->upper;
+}
diff --git a/dom/xslt/xslt/txXSLTNumber.h b/dom/xslt/xslt/txXSLTNumber.h
new file mode 100644
index 0000000000..ea4092e178
--- /dev/null
+++ b/dom/xslt/xslt/txXSLTNumber.h
@@ -0,0 +1,67 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef TRANSFRMX_TXXSLTNUMBER_H
+#define TRANSFRMX_TXXSLTNUMBER_H
+
+#include "nsError.h"
+#include "txList.h"
+#include "nsString.h"
+
+class Expr;
+class txPattern;
+class txIEvalContext;
+class txIMatchContext;
+class txXPathTreeWalker;
+
+class txXSLTNumber {
+ public:
+ enum LevelType { eLevelSingle, eLevelMultiple, eLevelAny };
+
+ static nsresult createNumber(Expr* aValueExpr, txPattern* aCountPattern,
+ txPattern* aFromPattern, LevelType aLevel,
+ Expr* aGroupSize, Expr* aGroupSeparator,
+ Expr* aFormat, txIEvalContext* aContext,
+ nsAString& aResult);
+
+ private:
+ static nsresult getValueList(Expr* aValueExpr, txPattern* aCountPattern,
+ txPattern* aFromPattern, LevelType aLevel,
+ txIEvalContext* aContext, txList& aValues,
+ nsAString& aValueString);
+
+ static nsresult getCounters(Expr* aGroupSize, Expr* aGroupSeparator,
+ Expr* aFormat, txIEvalContext* aContext,
+ txList& aCounters, nsAString& aHead,
+ nsAString& aTail);
+
+ /**
+ * getSiblingCount uses aWalker to walk the siblings of aWalker's current
+ * position.
+ *
+ */
+ static nsresult getSiblingCount(txXPathTreeWalker& aWalker,
+ txPattern* aCountPattern,
+ txIMatchContext* aContext, int32_t* aCount);
+
+ static bool getPrevInDocumentOrder(txXPathTreeWalker& aWalker);
+
+ static bool isAlphaNumeric(char16_t ch);
+};
+
+class txFormattedCounter {
+ public:
+ virtual ~txFormattedCounter() = default;
+
+ virtual void appendNumber(int32_t aNumber, nsAString& aDest) = 0;
+
+ static nsresult getCounterFor(const nsString& aToken, int aGroupSize,
+ const nsAString& aGroupSeparator,
+ txFormattedCounter*& aCounter);
+
+ nsString mSeparator;
+};
+
+#endif // TRANSFRMX_TXXSLTNUMBER_H
diff --git a/dom/xslt/xslt/txXSLTNumberCounters.cpp b/dom/xslt/xslt/txXSLTNumberCounters.cpp
new file mode 100644
index 0000000000..de1de46556
--- /dev/null
+++ b/dom/xslt/xslt/txXSLTNumberCounters.cpp
@@ -0,0 +1,199 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txXSLTNumber.h"
+#include "nsReadableUtils.h"
+#include "txCore.h"
+
+class txDecimalCounter : public txFormattedCounter {
+ public:
+ txDecimalCounter() : mMinLength(1), mGroupSize(50) {}
+
+ txDecimalCounter(int32_t aMinLength, int32_t aGroupSize,
+ const nsAString& mGroupSeparator);
+
+ virtual void appendNumber(int32_t aNumber, nsAString& aDest) override;
+
+ private:
+ int32_t mMinLength;
+ int32_t mGroupSize;
+ nsString mGroupSeparator;
+};
+
+class txAlphaCounter : public txFormattedCounter {
+ public:
+ explicit txAlphaCounter(char16_t aOffset) : mOffset(aOffset) {}
+
+ virtual void appendNumber(int32_t aNumber, nsAString& aDest) override;
+
+ private:
+ char16_t mOffset;
+};
+
+class txRomanCounter : public txFormattedCounter {
+ public:
+ explicit txRomanCounter(bool aUpper) : mTableOffset(aUpper ? 30 : 0) {}
+
+ void appendNumber(int32_t aNumber, nsAString& aDest) override;
+
+ private:
+ int32_t mTableOffset;
+};
+
+nsresult txFormattedCounter::getCounterFor(const nsString& aToken,
+ int32_t aGroupSize,
+ const nsAString& aGroupSeparator,
+ txFormattedCounter*& aCounter) {
+ int32_t length = aToken.Length();
+ NS_ASSERTION(length, "getting counter for empty token");
+ aCounter = 0;
+
+ if (length == 1) {
+ char16_t ch = aToken.CharAt(0);
+ switch (ch) {
+ case 'i':
+ case 'I':
+ aCounter = new txRomanCounter(ch == 'I');
+ break;
+
+ case 'a':
+ case 'A':
+ aCounter = new txAlphaCounter(ch);
+ break;
+
+ case '1':
+ default:
+ // if we don't recognize the token then use "1"
+ aCounter = new txDecimalCounter(1, aGroupSize, aGroupSeparator);
+ break;
+ }
+ MOZ_ASSERT(aCounter);
+ return NS_OK;
+ }
+
+ // for now, the only multi-char token we support are decimals
+ int32_t i;
+ for (i = 0; i < length - 1; ++i) {
+ if (aToken.CharAt(i) != '0') break;
+ }
+ if (i == length - 1 && aToken.CharAt(i) == '1') {
+ aCounter = new txDecimalCounter(length, aGroupSize, aGroupSeparator);
+ } else {
+ // if we don't recognize the token then use '1'
+ aCounter = new txDecimalCounter(1, aGroupSize, aGroupSeparator);
+ }
+ MOZ_ASSERT(aCounter);
+ return NS_OK;
+}
+
+txDecimalCounter::txDecimalCounter(int32_t aMinLength, int32_t aGroupSize,
+ const nsAString& aGroupSeparator)
+ : mMinLength(aMinLength),
+ mGroupSize(aGroupSize),
+ mGroupSeparator(aGroupSeparator) {
+ if (mGroupSize <= 0) {
+ mGroupSize = aMinLength + 10;
+ }
+}
+
+void txDecimalCounter::appendNumber(int32_t aNumber, nsAString& aDest) {
+ const int32_t bufsize = 10; // must be able to fit an int32_t
+ char16_t buf[bufsize];
+ int32_t pos = bufsize;
+ while (aNumber > 0) {
+ int32_t ch = aNumber % 10;
+ aNumber /= 10;
+ buf[--pos] = ch + '0';
+ }
+
+ // in case we didn't get a long enough string
+ int32_t end = (bufsize > mMinLength) ? bufsize - mMinLength : 0;
+ while (pos > end) {
+ buf[--pos] = '0';
+ }
+
+ // in case we *still* didn't get a long enough string.
+ // this should be very rare since it only happens if mMinLength is bigger
+ // then the length of any int32_t.
+ // pos will always be zero
+ int32_t extraPos = mMinLength;
+ while (extraPos > bufsize) {
+ aDest.Append(char16_t('0'));
+ --extraPos;
+ if (extraPos % mGroupSize == 0) {
+ aDest.Append(mGroupSeparator);
+ }
+ }
+
+ // copy string to buffer
+ if (mGroupSize >= bufsize - pos) {
+ // no grouping will occur
+ aDest.Append(buf + pos, (uint32_t)(bufsize - pos));
+ } else {
+ // append chars up to first grouping separator
+ int32_t len = ((bufsize - pos - 1) % mGroupSize) + 1;
+ aDest.Append(buf + pos, len);
+ pos += len;
+ while (bufsize - pos > 0) {
+ aDest.Append(mGroupSeparator);
+ aDest.Append(buf + pos, mGroupSize);
+ pos += mGroupSize;
+ }
+ NS_ASSERTION(bufsize == pos, "error while grouping");
+ }
+}
+
+void txAlphaCounter::appendNumber(int32_t aNumber, nsAString& aDest) {
+ char16_t buf[12];
+ buf[11] = 0;
+ int32_t pos = 11;
+ while (aNumber > 0) {
+ --aNumber;
+ int32_t ch = aNumber % 26;
+ aNumber /= 26;
+ buf[--pos] = ch + mOffset;
+ }
+
+ aDest.Append(buf + pos, (uint32_t)(11 - pos));
+}
+
+const char* const kTxRomanNumbers[] = {
+ "", "c", "cc", "ccc", "cd", "d", "dc", "dcc", "dccc", "cm",
+ "", "x", "xx", "xxx", "xl", "l", "lx", "lxx", "lxxx", "xc",
+ "", "i", "ii", "iii", "iv", "v", "vi", "vii", "viii", "ix",
+ "", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM",
+ "", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC",
+ "", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};
+
+void txRomanCounter::appendNumber(int32_t aNumber, nsAString& aDest) {
+ // Numbers bigger then 3999 and negative numbers can't be done in roman
+ if (uint32_t(aNumber) >= 4000) {
+ txDecimalCounter().appendNumber(aNumber, aDest);
+ return;
+ }
+
+ while (aNumber >= 1000) {
+ aDest.Append(!mTableOffset ? char16_t('m') : char16_t('M'));
+ aNumber -= 1000;
+ }
+
+ int32_t posValue;
+
+ // Hundreds
+ posValue = aNumber / 100;
+ aNumber %= 100;
+ AppendASCIItoUTF16(
+ mozilla::MakeStringSpan(kTxRomanNumbers[posValue + mTableOffset]), aDest);
+ // Tens
+ posValue = aNumber / 10;
+ aNumber %= 10;
+ AppendASCIItoUTF16(
+ mozilla::MakeStringSpan(kTxRomanNumbers[10 + posValue + mTableOffset]),
+ aDest);
+ // Ones
+ AppendASCIItoUTF16(
+ mozilla::MakeStringSpan(kTxRomanNumbers[20 + aNumber + mTableOffset]),
+ aDest);
+}
diff --git a/dom/xslt/xslt/txXSLTPatterns.cpp b/dom/xslt/xslt/txXSLTPatterns.cpp
new file mode 100644
index 0000000000..dc1b81e210
--- /dev/null
+++ b/dom/xslt/xslt/txXSLTPatterns.cpp
@@ -0,0 +1,530 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/FloatingPoint.h"
+
+#include "nsReadableUtils.h"
+#include "txExecutionState.h"
+#include "txXSLTPatterns.h"
+#include "txNodeSetContext.h"
+#include "txForwardContext.h"
+#include "txXMLUtils.h"
+#include "txXSLTFunctions.h"
+#include "nsWhitespaceTokenizer.h"
+#include "nsIContent.h"
+
+using mozilla::UniquePtr;
+using mozilla::Unused;
+using mozilla::WrapUnique;
+
+/*
+ * Returns the default priority of this Pattern.
+ * UnionPatterns don't like this.
+ * This should be called on the simple patterns.
+ */
+double txUnionPattern::getDefaultPriority() {
+ NS_ERROR("Don't call getDefaultPriority on txUnionPattern");
+ return mozilla::UnspecifiedNaN<double>();
+}
+
+/*
+ * Determines whether this Pattern matches the given node within
+ * the given context
+ * This should be called on the simple patterns for xsl:template,
+ * but is fine for xsl:key and xsl:number
+ */
+nsresult txUnionPattern::matches(const txXPathNode& aNode,
+ txIMatchContext* aContext, bool& aMatched) {
+ uint32_t i, len = mLocPathPatterns.Length();
+ for (i = 0; i < len; ++i) {
+ nsresult rv = mLocPathPatterns[i]->matches(aNode, aContext, aMatched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (aMatched) {
+ aMatched = true;
+
+ return NS_OK;
+ }
+ }
+
+ aMatched = false;
+
+ return NS_OK;
+}
+
+txPattern::Type txUnionPattern::getType() { return UNION_PATTERN; }
+
+TX_IMPL_PATTERN_STUBS_NO_SUB_EXPR(txUnionPattern)
+txPattern* txUnionPattern::getSubPatternAt(uint32_t aPos) {
+ return mLocPathPatterns.SafeElementAt(aPos);
+}
+
+void txUnionPattern::setSubPatternAt(uint32_t aPos, txPattern* aPattern) {
+ NS_ASSERTION(aPos < mLocPathPatterns.Length(),
+ "setting bad subexpression index");
+ mLocPathPatterns[aPos] = aPattern;
+}
+
+#ifdef TX_TO_STRING
+void txUnionPattern::toString(nsAString& aDest) {
+# ifdef DEBUG
+ aDest.AppendLiteral("txUnionPattern{");
+# endif
+ StringJoinAppend(
+ aDest, u" | "_ns, mLocPathPatterns,
+ [](nsAString& dest, txPattern* pattern) { pattern->toString(dest); });
+# ifdef DEBUG
+ aDest.Append(char16_t('}'));
+# endif
+}
+#endif
+
+/*
+ * LocationPathPattern
+ *
+ * a list of step patterns, can start with id or key
+ * (dealt with by the parser)
+ */
+
+void txLocPathPattern::addStep(txPattern* aPattern, bool isChild) {
+ Step* step = mSteps.AppendElement();
+ step->pattern = WrapUnique(aPattern);
+ step->isChild = isChild;
+}
+
+nsresult txLocPathPattern::matches(const txXPathNode& aNode,
+ txIMatchContext* aContext, bool& aMatched) {
+ NS_ASSERTION(mSteps.Length() > 1, "Internal error");
+
+ /*
+ * The idea is to split up a path into blocks separated by descendant
+ * operators. For example "foo/bar//baz/bop//ying/yang" is split up into
+ * three blocks. The "ying/yang" block is handled by the first while-loop
+ * and the "foo/bar" and "baz/bop" blocks are handled by the second
+ * while-loop.
+ * A block is considered matched when we find a list of ancestors that
+ * match the block. If there are more than one list of ancestors that
+ * match a block we only need to find the one furthermost down in the
+ * tree.
+ */
+
+ uint32_t pos = mSteps.Length();
+ Step* step = &mSteps[--pos];
+ nsresult rv = step->pattern->matches(aNode, aContext, aMatched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (!aMatched) {
+ return NS_OK;
+ }
+
+ txXPathTreeWalker walker(aNode);
+ bool hasParent = walker.moveToParent();
+
+ while (step->isChild) {
+ if (!pos) {
+ aMatched = true;
+
+ return NS_OK; // all steps matched
+ }
+
+ if (!hasParent) {
+ // no more ancestors
+ aMatched = false;
+
+ return NS_OK;
+ }
+
+ step = &mSteps[--pos];
+ rv =
+ step->pattern->matches(walker.getCurrentPosition(), aContext, aMatched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (!aMatched) {
+ // no match
+ return NS_OK;
+ }
+
+ hasParent = walker.moveToParent();
+ }
+
+ // We have at least one // path separator
+ txXPathTreeWalker blockWalker(walker);
+ uint32_t blockPos = pos;
+
+ while (pos) {
+ if (!hasParent) {
+ aMatched = false; // There are more steps in the current block
+ // than ancestors of the tested node
+ return NS_OK;
+ }
+
+ step = &mSteps[--pos];
+ bool matched;
+ rv = step->pattern->matches(walker.getCurrentPosition(), aContext, matched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (!matched) {
+ // Didn't match. We restart at beginning of block using a new
+ // start node
+ pos = blockPos;
+ hasParent = blockWalker.moveToParent();
+ walker.moveTo(blockWalker);
+ } else {
+ hasParent = walker.moveToParent();
+ if (!step->isChild) {
+ // We've matched an entire block. Set new start pos and start node
+ blockPos = pos;
+ blockWalker.moveTo(walker);
+ }
+ }
+ }
+
+ aMatched = true;
+
+ return NS_OK;
+} // txLocPathPattern::matches
+
+double txLocPathPattern::getDefaultPriority() {
+ NS_ASSERTION(mSteps.Length() > 1, "Internal error");
+
+ return 0.5;
+}
+
+TX_IMPL_PATTERN_STUBS_NO_SUB_EXPR(txLocPathPattern)
+txPattern* txLocPathPattern::getSubPatternAt(uint32_t aPos) {
+ return aPos < mSteps.Length() ? mSteps[aPos].pattern.get() : nullptr;
+}
+
+void txLocPathPattern::setSubPatternAt(uint32_t aPos, txPattern* aPattern) {
+ NS_ASSERTION(aPos < mSteps.Length(), "setting bad subexpression index");
+ Step* step = &mSteps[aPos];
+ Unused << step->pattern.release();
+ step->pattern = WrapUnique(aPattern);
+}
+
+#ifdef TX_TO_STRING
+void txLocPathPattern::toString(nsAString& aDest) {
+# ifdef DEBUG
+ aDest.AppendLiteral("txLocPathPattern{");
+# endif
+ for (uint32_t i = 0; i < mSteps.Length(); ++i) {
+ if (i != 0) {
+ if (mSteps[i].isChild)
+ aDest.Append(char16_t('/'));
+ else
+ aDest.AppendLiteral("//");
+ }
+ mSteps[i].pattern->toString(aDest);
+ }
+# ifdef DEBUG
+ aDest.Append(char16_t('}'));
+# endif
+}
+#endif
+
+/*
+ * txRootPattern
+ *
+ * a txPattern matching the document node, or '/'
+ */
+
+nsresult txRootPattern::matches(const txXPathNode& aNode,
+ txIMatchContext* aContext, bool& aMatched) {
+ aMatched = txXPathNodeUtils::isRoot(aNode);
+
+ return NS_OK;
+}
+
+double txRootPattern::getDefaultPriority() { return 0.5; }
+
+TX_IMPL_PATTERN_STUBS_NO_SUB_EXPR(txRootPattern)
+TX_IMPL_PATTERN_STUBS_NO_SUB_PATTERN(txRootPattern)
+
+#ifdef TX_TO_STRING
+void txRootPattern::toString(nsAString& aDest) {
+# ifdef DEBUG
+ aDest.AppendLiteral("txRootPattern{");
+# endif
+ if (mSerialize) aDest.Append(char16_t('/'));
+# ifdef DEBUG
+ aDest.Append(char16_t('}'));
+# endif
+}
+#endif
+
+/*
+ * txIdPattern
+ *
+ * txIdPattern matches if the given node has a ID attribute with one
+ * of the space delimited values.
+ * This looks like the id() function, but may only have LITERALs as
+ * argument.
+ */
+txIdPattern::txIdPattern(const nsAString& aString) {
+ nsWhitespaceTokenizer tokenizer(aString);
+ while (tokenizer.hasMoreTokens()) {
+ // this can fail, XXX move to a Init(aString) method
+ RefPtr<nsAtom> atom = NS_Atomize(tokenizer.nextToken());
+ mIds.AppendElement(atom);
+ }
+}
+
+nsresult txIdPattern::matches(const txXPathNode& aNode,
+ txIMatchContext* aContext, bool& aMatched) {
+ if (!txXPathNodeUtils::isElement(aNode)) {
+ aMatched = false;
+
+ return NS_OK;
+ }
+
+ // Get a ID attribute, if there is
+ nsIContent* content = txXPathNativeNode::getContent(aNode);
+ NS_ASSERTION(content, "a Element without nsIContent");
+
+ nsAtom* id = content->GetID();
+ aMatched = id && mIds.IndexOf(id) != mIds.NoIndex;
+
+ return NS_OK;
+}
+
+double txIdPattern::getDefaultPriority() { return 0.5; }
+
+TX_IMPL_PATTERN_STUBS_NO_SUB_EXPR(txIdPattern)
+TX_IMPL_PATTERN_STUBS_NO_SUB_PATTERN(txIdPattern)
+
+#ifdef TX_TO_STRING
+void txIdPattern::toString(nsAString& aDest) {
+# ifdef DEBUG
+ aDest.AppendLiteral("txIdPattern{");
+# endif
+ aDest.AppendLiteral("id('");
+ uint32_t k, count = mIds.Length() - 1;
+ for (k = 0; k < count; ++k) {
+ nsAutoString str;
+ mIds[k]->ToString(str);
+ aDest.Append(str);
+ aDest.Append(char16_t(' '));
+ }
+ nsAutoString str;
+ mIds[count]->ToString(str);
+ aDest.Append(str);
+ aDest.AppendLiteral("')");
+# ifdef DEBUG
+ aDest.Append(char16_t('}'));
+# endif
+}
+#endif
+
+/*
+ * txKeyPattern
+ *
+ * txKeyPattern matches if the given node is in the evalation of
+ * the key() function
+ * This resembles the key() function, but may only have LITERALs as
+ * argument.
+ */
+
+nsresult txKeyPattern::matches(const txXPathNode& aNode,
+ txIMatchContext* aContext, bool& aMatched) {
+ txExecutionState* es = (txExecutionState*)aContext->getPrivateContext();
+ UniquePtr<txXPathNode> contextDoc(txXPathNodeUtils::getOwnerDocument(aNode));
+ NS_ENSURE_TRUE(contextDoc, NS_ERROR_FAILURE);
+
+ RefPtr<txNodeSet> nodes;
+ nsresult rv =
+ es->getKeyNodes(mName, *contextDoc, mValue, true, getter_AddRefs(nodes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aMatched = nodes->contains(aNode);
+
+ return NS_OK;
+}
+
+double txKeyPattern::getDefaultPriority() { return 0.5; }
+
+TX_IMPL_PATTERN_STUBS_NO_SUB_EXPR(txKeyPattern)
+TX_IMPL_PATTERN_STUBS_NO_SUB_PATTERN(txKeyPattern)
+
+#ifdef TX_TO_STRING
+void txKeyPattern::toString(nsAString& aDest) {
+# ifdef DEBUG
+ aDest.AppendLiteral("txKeyPattern{");
+# endif
+ aDest.AppendLiteral("key('");
+ nsAutoString tmp;
+ if (mPrefix) {
+ mPrefix->ToString(tmp);
+ aDest.Append(tmp);
+ aDest.Append(char16_t(':'));
+ }
+ mName.mLocalName->ToString(tmp);
+ aDest.Append(tmp);
+ aDest.AppendLiteral(", ");
+ aDest.Append(mValue);
+ aDest.AppendLiteral("')");
+# ifdef DEBUG
+ aDest.Append(char16_t('}'));
+# endif
+}
+#endif
+
+/*
+ * txStepPattern
+ *
+ * a txPattern to hold the NodeTest and the Predicates of a StepPattern
+ */
+
+nsresult txStepPattern::matches(const txXPathNode& aNode,
+ txIMatchContext* aContext, bool& aMatched) {
+ NS_ASSERTION(mNodeTest, "Internal error");
+
+ nsresult rv = mNodeTest->matches(aNode, aContext, aMatched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (!aMatched) {
+ return NS_OK;
+ }
+
+ txXPathTreeWalker walker(aNode);
+ if ((!mIsAttr &&
+ txXPathNodeUtils::isAttribute(walker.getCurrentPosition())) ||
+ !walker.moveToParent()) {
+ aMatched = false;
+
+ return NS_OK;
+ }
+
+ if (isEmpty()) {
+ aMatched = true;
+
+ return NS_OK;
+ }
+
+ /*
+ * Evaluate Predicates
+ *
+ * Copy all siblings/attributes matching mNodeTest to nodes
+ * Up to the last Predicate do
+ * Foreach node in nodes
+ * evaluate Predicate with node as context node
+ * if the result is a number, check the context position,
+ * otherwise convert to bool
+ * if result is true, copy node to newNodes
+ * if aNode is not member of newNodes, return false
+ * nodes = newNodes
+ *
+ * For the last Predicate, evaluate Predicate with aNode as
+ * context node, if the result is a number, check the position,
+ * otherwise return the result converted to boolean
+ */
+
+ // Create the context node set for evaluating the predicates
+ RefPtr<txNodeSet> nodes;
+ rv = aContext->recycler()->getNodeSet(getter_AddRefs(nodes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ bool hasNext =
+ mIsAttr ? walker.moveToFirstAttribute() : walker.moveToFirstChild();
+ while (hasNext) {
+ bool matched;
+ rv = mNodeTest->matches(walker.getCurrentPosition(), aContext, matched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (matched) {
+ nodes->append(walker.getCurrentPosition());
+ }
+ hasNext =
+ mIsAttr ? walker.moveToNextAttribute() : walker.moveToNextSibling();
+ }
+
+ Expr* predicate = mPredicates[0];
+ RefPtr<txNodeSet> newNodes;
+ rv = aContext->recycler()->getNodeSet(getter_AddRefs(newNodes));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ uint32_t i, predLen = mPredicates.Length();
+ for (i = 1; i < predLen; ++i) {
+ newNodes->clear();
+ bool contextIsInPredicate = false;
+ txNodeSetContext predContext(nodes, aContext);
+ while (predContext.hasNext()) {
+ predContext.next();
+ RefPtr<txAExprResult> exprResult;
+ rv = predicate->evaluate(&predContext, getter_AddRefs(exprResult));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ switch (exprResult->getResultType()) {
+ case txAExprResult::NUMBER:
+ // handle default, [position() == numberValue()]
+ if ((double)predContext.position() == exprResult->numberValue()) {
+ const txXPathNode& tmp = predContext.getContextNode();
+ if (tmp == aNode) contextIsInPredicate = true;
+ newNodes->append(tmp);
+ }
+ break;
+ default:
+ if (exprResult->booleanValue()) {
+ const txXPathNode& tmp = predContext.getContextNode();
+ if (tmp == aNode) contextIsInPredicate = true;
+ newNodes->append(tmp);
+ }
+ break;
+ }
+ }
+ // Move new NodeSet to the current one
+ nodes->clear();
+ nodes->append(*newNodes);
+ if (!contextIsInPredicate) {
+ aMatched = false;
+
+ return NS_OK;
+ }
+ predicate = mPredicates[i];
+ }
+ txForwardContext evalContext(aContext, aNode, nodes);
+ RefPtr<txAExprResult> exprResult;
+ rv = predicate->evaluate(&evalContext, getter_AddRefs(exprResult));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (exprResult->getResultType() == txAExprResult::NUMBER) {
+ // handle default, [position() == numberValue()]
+ aMatched = ((double)evalContext.position() == exprResult->numberValue());
+ } else {
+ aMatched = exprResult->booleanValue();
+ }
+
+ return NS_OK;
+} // matches
+
+double txStepPattern::getDefaultPriority() {
+ if (isEmpty()) return mNodeTest->getDefaultPriority();
+ return 0.5;
+}
+
+txPattern::Type txStepPattern::getType() { return STEP_PATTERN; }
+
+TX_IMPL_PATTERN_STUBS_NO_SUB_PATTERN(txStepPattern)
+Expr* txStepPattern::getSubExprAt(uint32_t aPos) {
+ return PredicateList::getSubExprAt(aPos);
+}
+
+void txStepPattern::setSubExprAt(uint32_t aPos, Expr* aExpr) {
+ PredicateList::setSubExprAt(aPos, aExpr);
+}
+
+#ifdef TX_TO_STRING
+void txStepPattern::toString(nsAString& aDest) {
+# ifdef DEBUG
+ aDest.AppendLiteral("txStepPattern{");
+# endif
+ if (mIsAttr) aDest.Append(char16_t('@'));
+ if (mNodeTest) mNodeTest->toString(aDest);
+
+ PredicateList::toString(aDest);
+# ifdef DEBUG
+ aDest.Append(char16_t('}'));
+# endif
+}
+#endif
diff --git a/dom/xslt/xslt/txXSLTPatterns.h b/dom/xslt/xslt/txXSLTPatterns.h
new file mode 100644
index 0000000000..6d6a5d8723
--- /dev/null
+++ b/dom/xslt/xslt/txXSLTPatterns.h
@@ -0,0 +1,200 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef TX_XSLT_PATTERNS_H
+#define TX_XSLT_PATTERNS_H
+
+#include "mozilla/Attributes.h"
+#include "txExpandedName.h"
+#include "txExpr.h"
+#include "txXMLUtils.h"
+
+class txPattern {
+ public:
+ MOZ_COUNTED_DEFAULT_CTOR(txPattern)
+ MOZ_COUNTED_DTOR_VIRTUAL(txPattern)
+
+ /*
+ * Determines whether this Pattern matches the given node.
+ */
+ virtual nsresult matches(const txXPathNode& aNode, txIMatchContext* aContext,
+ bool& aMatched) = 0;
+
+ /*
+ * Returns the default priority of this Pattern.
+ *
+ * Simple Patterns return the values as specified in XPath 5.5.
+ * Returns -Inf for union patterns, as it shouldn't be called on them.
+ */
+ virtual double getDefaultPriority() = 0;
+
+ /**
+ * Returns the type of this pattern.
+ */
+ enum Type { STEP_PATTERN, UNION_PATTERN, OTHER_PATTERN };
+ virtual Type getType() { return OTHER_PATTERN; }
+
+ /**
+ * Returns sub-expression at given position
+ */
+ virtual Expr* getSubExprAt(uint32_t aPos) = 0;
+
+ /**
+ * Replace sub-expression at given position. Does not delete the old
+ * expression, that is the responsibility of the caller.
+ */
+ virtual void setSubExprAt(uint32_t aPos, Expr* aExpr) = 0;
+
+ /**
+ * Returns sub-pattern at given position
+ */
+ virtual txPattern* getSubPatternAt(uint32_t aPos) = 0;
+
+ /**
+ * Replace sub-pattern at given position. Does not delete the old
+ * pattern, that is the responsibility of the caller.
+ */
+ virtual void setSubPatternAt(uint32_t aPos, txPattern* aPattern) = 0;
+
+#ifdef TX_TO_STRING
+ /*
+ * Returns the String representation of this Pattern.
+ * @param dest the String to use when creating the String
+ * representation. The String representation will be appended to
+ * any data in the destination String, to allow cascading calls to
+ * other #toString() methods for Patterns.
+ * @return the String representation of this Pattern.
+ */
+ virtual void toString(nsAString& aDest) = 0;
+#endif
+};
+
+#define TX_DECL_PATTERN_BASE \
+ nsresult matches(const txXPathNode& aNode, txIMatchContext* aContext, \
+ bool& aMatched) override; \
+ double getDefaultPriority() override; \
+ virtual Expr* getSubExprAt(uint32_t aPos) override; \
+ virtual void setSubExprAt(uint32_t aPos, Expr* aExpr) override; \
+ virtual txPattern* getSubPatternAt(uint32_t aPos) override; \
+ virtual void setSubPatternAt(uint32_t aPos, txPattern* aPattern) override
+
+#ifndef TX_TO_STRING
+# define TX_DECL_PATTERN TX_DECL_PATTERN_BASE
+#else
+# define TX_DECL_PATTERN \
+ TX_DECL_PATTERN_BASE; \
+ void toString(nsAString& aDest) override
+#endif
+
+#define TX_IMPL_PATTERN_STUBS_NO_SUB_EXPR(_class) \
+ Expr* _class::getSubExprAt(uint32_t aPos) { return nullptr; } \
+ void _class::setSubExprAt(uint32_t aPos, Expr* aExpr) { \
+ MOZ_ASSERT_UNREACHABLE("setting bad subexpression index"); \
+ }
+
+#define TX_IMPL_PATTERN_STUBS_NO_SUB_PATTERN(_class) \
+ txPattern* _class::getSubPatternAt(uint32_t aPos) { return nullptr; } \
+ void _class::setSubPatternAt(uint32_t aPos, txPattern* aPattern) { \
+ MOZ_ASSERT_UNREACHABLE("setting bad subexpression index"); \
+ }
+
+class txUnionPattern : public txPattern {
+ public:
+ void addPattern(txPattern* aPattern) {
+ mLocPathPatterns.AppendElement(aPattern);
+ }
+
+ TX_DECL_PATTERN;
+ Type getType() override;
+
+ private:
+ txOwningArray<txPattern> mLocPathPatterns;
+};
+
+class txLocPathPattern : public txPattern {
+ public:
+ void addStep(txPattern* aPattern, bool isChild);
+
+ TX_DECL_PATTERN;
+
+ private:
+ class Step {
+ public:
+ mozilla::UniquePtr<txPattern> pattern;
+ bool isChild;
+ };
+
+ nsTArray<Step> mSteps;
+};
+
+class txRootPattern : public txPattern {
+ public:
+#ifdef TX_TO_STRING
+ txRootPattern() : mSerialize(true) {}
+#endif
+
+ TX_DECL_PATTERN;
+
+#ifdef TX_TO_STRING
+ public:
+ void setSerialize(bool aSerialize) { mSerialize = aSerialize; }
+
+ private:
+ // Don't serialize txRootPattern if it's used in a txLocPathPattern
+ bool mSerialize;
+#endif
+};
+
+class txIdPattern : public txPattern {
+ public:
+ explicit txIdPattern(const nsAString& aString);
+
+ TX_DECL_PATTERN;
+
+ private:
+ nsTArray<RefPtr<nsAtom>> mIds;
+};
+
+class txKeyPattern : public txPattern {
+ public:
+ txKeyPattern(nsAtom* aPrefix, nsAtom* aLocalName, int32_t aNSID,
+ const nsAString& aValue)
+ : mName(aNSID, aLocalName),
+#ifdef TX_TO_STRING
+ mPrefix(aPrefix),
+#endif
+ mValue(aValue) {
+ }
+
+ TX_DECL_PATTERN;
+
+ private:
+ txExpandedName mName;
+#ifdef TX_TO_STRING
+ RefPtr<nsAtom> mPrefix;
+#endif
+ nsString mValue;
+};
+
+class txStepPattern : public txPattern, public PredicateList {
+ public:
+ txStepPattern(txNodeTest* aNodeTest, bool isAttr)
+ : mNodeTest(aNodeTest), mIsAttr(isAttr) {}
+
+ TX_DECL_PATTERN;
+ Type getType() override;
+
+ txNodeTest* getNodeTest() { return mNodeTest.get(); }
+ void setNodeTest(txNodeTest* aNodeTest) {
+ mozilla::Unused << mNodeTest.release();
+ mNodeTest = mozilla::WrapUnique(aNodeTest);
+ }
+
+ private:
+ mozilla::UniquePtr<txNodeTest> mNodeTest;
+ bool mIsAttr;
+};
+
+#endif // TX_XSLT_PATTERNS_H
diff --git a/dom/xslt/xslt/txXSLTProcessor.cpp b/dom/xslt/xslt/txXSLTProcessor.cpp
new file mode 100644
index 0000000000..bcf1a61108
--- /dev/null
+++ b/dom/xslt/xslt/txXSLTProcessor.cpp
@@ -0,0 +1,50 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "txXSLTProcessor.h"
+#include "txInstructions.h"
+#include "nsGkAtoms.h"
+#include "txLog.h"
+#include "txStylesheetCompileHandlers.h"
+#include "txStylesheetCompiler.h"
+#include "txExecutionState.h"
+#include "txExprResult.h"
+
+TX_LG_IMPL
+
+/* static */
+bool txXSLTProcessor::init() {
+ TX_LG_CREATE;
+
+ if (!txHandlerTable::init()) return false;
+
+ extern bool TX_InitEXSLTFunction();
+ if (!TX_InitEXSLTFunction()) return false;
+
+ return true;
+}
+
+/* static */
+void txXSLTProcessor::shutdown() { txHandlerTable::shutdown(); }
+
+/* static */
+nsresult txXSLTProcessor::execute(txExecutionState& aEs) {
+ nsresult rv;
+ do {
+ mozilla::Result<txInstruction*, nsresult> result = aEs.getNextInstruction();
+ if (result.isErr()) {
+ return result.unwrapErr();
+ }
+
+ txInstruction* instr = result.unwrap();
+ if (!instr) {
+ return NS_OK;
+ }
+
+ rv = instr->execute(aEs);
+ } while (NS_SUCCEEDED(rv));
+
+ return rv;
+}
diff --git a/dom/xslt/xslt/txXSLTProcessor.h b/dom/xslt/xslt/txXSLTProcessor.h
new file mode 100644
index 0000000000..f06a885219
--- /dev/null
+++ b/dom/xslt/xslt/txXSLTProcessor.h
@@ -0,0 +1,26 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef TRANSFRMX_TXXSLTPROCESSOR_H
+#define TRANSFRMX_TXXSLTPROCESSOR_H
+
+#include "txExecutionState.h"
+
+class txXSLTProcessor {
+ public:
+ /**
+ * Initialisation and shutdown routines. Initilizes and cleansup all
+ * dependant classes
+ */
+ static bool init();
+ static void shutdown();
+
+ static nsresult execute(txExecutionState& aEs);
+
+ // once we want to have interuption we should probably have functions for
+ // running X number of steps or running until a condition is true.
+};
+
+#endif