summaryrefslogtreecommitdiffstats
path: root/dom/xslt/xml
diff options
context:
space:
mode:
Diffstat (limited to 'dom/xslt/xml')
-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
5 files changed, 344 insertions, 0 deletions
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
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-01 11:54:48 +0000