--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/webengine/osswebengine/WebCore/xml/XSLTProcessor.cpp Mon Mar 30 12:54:55 2009 +0300
@@ -0,0 +1,419 @@
+/**
+ * This file is part of the XSL implementation.
+ *
+ * Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.
+ * Copyright (C) 2005, 2006 Alexey Proskuryakov <ap@webkit.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+
+#if ENABLE(XSLT)
+
+#include "XSLTProcessor.h"
+
+#include "CString.h"
+#include "Cache.h"
+#include "DOMImplementation.h"
+#include "DocLoader.h"
+#include "DocumentFragment.h"
+#include "Frame.h"
+#include "FrameLoader.h"
+#include "FrameView.h"
+#include "HTMLDocument.h"
+#include "HTMLTokenizer.h"
+#include "ResourceHandle.h"
+#include "ResourceRequest.h"
+#include "ResourceResponse.h"
+#include "Text.h"
+#include "TextResourceDecoder.h"
+#include "XMLTokenizer.h"
+#include "XSLTExtensions.h"
+#include "loader.h"
+#include "markup.h"
+#include <libxslt/imports.h>
+#include <libxslt/variables.h>
+#include <libxslt/xsltutils.h>
+#include <wtf/Assertions.h>
+#include <wtf/Platform.h>
+#include <wtf/Vector.h>
+#if PLATFORM(MAC)
+#include "SoftLinking.h"
+#endif
+
+#if PLATFORM(MAC)
+SOFT_LINK_LIBRARY(libxslt);
+SOFT_LINK(libxslt, xsltFreeStylesheet, void, (xsltStylesheetPtr sheet), (sheet))
+SOFT_LINK(libxslt, xsltFreeTransformContext, void, (xsltTransformContextPtr ctxt), (ctxt))
+SOFT_LINK(libxslt, xsltNewTransformContext, xsltTransformContextPtr, (xsltStylesheetPtr style, xmlDocPtr doc), (style, doc))
+SOFT_LINK(libxslt, xsltApplyStylesheetUser, xmlDocPtr, (xsltStylesheetPtr style, xmlDocPtr doc, const char **params, const char *output, FILE * profile, xsltTransformContextPtr userCtxt), (style, doc, params, output, profile, userCtxt))
+SOFT_LINK(libxslt, xsltQuoteUserParams, int, (xsltTransformContextPtr ctxt, const char **params), (ctxt, params))
+SOFT_LINK(libxslt, xsltSetLoaderFunc, void, (xsltDocLoaderFunc f), (f))
+SOFT_LINK(libxslt, xsltSaveResultTo, int, (xmlOutputBufferPtr buf, xmlDocPtr result, xsltStylesheetPtr style), (buf, result, style))
+SOFT_LINK(libxslt, xsltNextImport, xsltStylesheetPtr, (xsltStylesheetPtr style), (style))
+#endif
+
+namespace WebCore {
+
+static void parseErrorFunc(void *ctxt, const char *msg, ...)
+{
+ // FIXME: It would be nice to display error messages somewhere.
+#if !PLATFORM(WIN_OS)
+ // FIXME: No vasprintf support.
+#ifndef ERROR_DISABLED
+ char *errorMessage = 0;
+ va_list args;
+ va_start(args, msg);
+ vasprintf(&errorMessage, msg, args);
+ LOG_ERROR("%s", errorMessage);
+ if (errorMessage)
+ free(errorMessage);
+ va_end(args);
+#endif
+#endif
+}
+
+// FIXME: There seems to be no way to control the ctxt pointer for loading here, thus we have globals.
+static XSLTProcessor *globalProcessor = 0;
+static DocLoader *globalDocLoader = 0;
+static xmlDocPtr docLoaderFunc(const xmlChar *uri,
+ xmlDictPtr dict,
+ int options,
+ void* ctxt,
+ xsltLoadType type)
+{
+ if (!globalProcessor)
+ return 0;
+
+ switch (type) {
+ case XSLT_LOAD_DOCUMENT: {
+ xsltTransformContextPtr context = (xsltTransformContextPtr)ctxt;
+ xmlChar *base = xmlNodeGetBase(context->document->doc, context->node);
+ KURL url((const char*)base, (const char*)uri);
+ xmlFree(base);
+ ResourceError error;
+ ResourceResponse response;
+ xmlGenericErrorFunc oldErrorFunc = xmlGenericError;
+ void *oldErrorContext = xmlGenericErrorContext;
+
+ Vector<char> data;
+
+ if (globalDocLoader->frame())
+ globalDocLoader->frame()->loader()->loadResourceSynchronously(url, error, response, data);
+
+ xmlSetGenericErrorFunc(0, parseErrorFunc);
+ // We don't specify an encoding here. Neither Gecko nor WinIE respects
+ // the encoding specified in the HTTP headers.
+ xmlDocPtr doc = xmlReadMemory(data.data(), data.size(), (const char*)uri, 0, options);
+ xmlSetGenericErrorFunc(oldErrorContext, oldErrorFunc);
+ return doc;
+ }
+ case XSLT_LOAD_STYLESHEET:
+ return globalProcessor->xslStylesheet()->locateStylesheetSubResource(((xsltStylesheetPtr)ctxt)->doc, uri);
+ default:
+ break;
+ }
+
+ return 0;
+}
+
+static inline void setXSLTLoadCallBack(xsltDocLoaderFunc func, XSLTProcessor *processor, DocLoader *loader)
+{
+ xsltSetLoaderFunc(func);
+ globalProcessor = processor;
+ globalDocLoader = loader;
+}
+
+static int writeToQString(void *context, const char *buffer, int len)
+{
+ DeprecatedString &resultOutput = *static_cast<DeprecatedString *>(context);
+ resultOutput += DeprecatedString::fromUtf8(buffer, len);
+ return len;
+}
+
+static bool saveResultToString(xmlDocPtr resultDoc, xsltStylesheetPtr sheet, DeprecatedString &resultString)
+{
+ xmlOutputBufferPtr outputBuf = xmlAllocOutputBuffer(0);
+ if (!outputBuf)
+ return false;
+ outputBuf->context = &resultString;
+ outputBuf->writecallback = writeToQString;
+
+ int retval = xsltSaveResultTo(outputBuf, resultDoc, sheet);
+ xmlOutputBufferClose(outputBuf);
+
+ return (retval >= 0);
+}
+
+static inline void transformTextStringToXHTMLDocumentString(String &text)
+{
+ // Modify the output so that it is a well-formed XHTML document with a <pre> tag enclosing the text.
+ text.replace('&', "&");
+ text.replace('<', "<");
+ text = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+ "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n"
+ "<html xmlns=\"http://www.w3.org/1999/xhtml\">\n"
+ "<head><title/></head>\n"
+ "<body>\n"
+ "<pre>" + text + "</pre>\n"
+ "</body>\n"
+ "</html>\n";
+}
+
+static const char **xsltParamArrayFromParameterMap(XSLTProcessor::ParameterMap& parameters)
+{
+ if (parameters.isEmpty())
+ return 0;
+
+ const char **parameterArray = (const char **)fastMalloc(((parameters.size() * 2) + 1) * sizeof(char *));
+
+ XSLTProcessor::ParameterMap::iterator end = parameters.end();
+ unsigned index = 0;
+ for (XSLTProcessor::ParameterMap::iterator it = parameters.begin(); it != end; ++it) {
+ parameterArray[index++] = strdup(it->first.utf8().data());
+ parameterArray[index++] = strdup(it->second.utf8().data());
+ }
+ parameterArray[index] = 0;
+
+ return parameterArray;
+}
+
+static void freeXsltParamArray(const char **params)
+{
+ const char **temp = params;
+ if (!params)
+ return;
+
+ while (*temp) {
+ free((void *)*(temp++)); // strdup returns malloc'd blocks, so we have to use free() here
+ free((void *)*(temp++));
+ }
+ fastFree(params);
+}
+
+
+RefPtr<Document> XSLTProcessor::createDocumentFromSource(const DeprecatedString& sourceString,
+ const DeprecatedString& sourceEncoding, const DeprecatedString& sourceMIMEType, Node* sourceNode, Frame* frame)
+{
+ RefPtr<Document> ownerDocument = sourceNode->document();
+ bool sourceIsDocument = (sourceNode == ownerDocument.get());
+ String documentSource = sourceString;
+
+ RefPtr<Document> result;
+ if (sourceMIMEType == "text/plain") {
+ result = ownerDocument->implementation()->createDocument(frame);
+ transformTextStringToXHTMLDocumentString(documentSource);
+ } else
+ result = ownerDocument->implementation()->createDocument(sourceMIMEType, frame, false);
+
+ // Before parsing, we need to save & detach the old document and get the new document
+ // in place. We have to do this only if we're rendering the result document.
+ if (frame) {
+ if (FrameView* view = frame->view())
+ view->clear();
+ result->setTransformSourceDocument(frame->document());
+ frame->setDocument(result);
+ }
+
+ result->open();
+ if (sourceIsDocument) {
+ result->setURL(ownerDocument->URL());
+ result->setBaseURL(ownerDocument->baseURL());
+ }
+ result->determineParseMode(documentSource); // Make sure we parse in the correct mode.
+
+ RefPtr<TextResourceDecoder> decoder = new TextResourceDecoder(sourceMIMEType);
+ decoder->setEncoding(sourceEncoding.isEmpty() ? UTF8Encoding() : TextEncoding(sourceEncoding), TextResourceDecoder::EncodingFromXMLHeader);
+ result->setDecoder(decoder.get());
+
+ result->write(documentSource);
+ result->finishParsing();
+ result->close();
+
+ return result;
+}
+
+static inline RefPtr<DocumentFragment> createFragmentFromSource(DeprecatedString sourceString, DeprecatedString sourceMIMEType, Node *sourceNode, Document *outputDoc)
+{
+ RefPtr<DocumentFragment> fragment = new DocumentFragment(outputDoc);
+
+ if (sourceMIMEType == "text/html")
+ parseHTMLDocumentFragment(sourceString, fragment.get());
+ else if (sourceMIMEType == "text/plain")
+ fragment->addChild(new Text(outputDoc, sourceString));
+ else {
+ bool successfulParse = parseXMLDocumentFragment(sourceString, fragment.get(), outputDoc->documentElement());
+ if (!successfulParse)
+ return 0;
+ }
+
+ // FIXME: Do we need to mess with URLs here?
+
+ return fragment;
+}
+
+static xsltStylesheetPtr xsltStylesheetPointer(RefPtr<XSLStyleSheet> &cachedStylesheet, Node *stylesheetRootNode)
+{
+ if (!cachedStylesheet && stylesheetRootNode) {
+ cachedStylesheet = new XSLStyleSheet(stylesheetRootNode->parent() ? stylesheetRootNode->parent() : stylesheetRootNode, stylesheetRootNode->document()->URL());
+ cachedStylesheet->parseString(createMarkup(stylesheetRootNode));
+ }
+
+ if (!cachedStylesheet || !cachedStylesheet->document())
+ return 0;
+
+ return cachedStylesheet->compileStyleSheet();
+}
+
+static inline xmlDocPtr xmlDocPtrFromNode(Node *sourceNode, bool &shouldDelete)
+{
+ RefPtr<Document> ownerDocument = sourceNode->document();
+ bool sourceIsDocument = (sourceNode == ownerDocument.get());
+
+ xmlDocPtr sourceDoc = 0;
+ if (sourceIsDocument)
+ sourceDoc = (xmlDocPtr)ownerDocument->transformSource();
+ if (!sourceDoc) {
+ sourceDoc = (xmlDocPtr)xmlDocPtrForString(ownerDocument->docLoader(), createMarkup(sourceNode), sourceIsDocument ? ownerDocument->URL() : DeprecatedString());
+ shouldDelete = (sourceDoc != 0);
+ }
+ return sourceDoc;
+}
+
+static inline DeprecatedString resultMIMEType(xmlDocPtr resultDoc, xsltStylesheetPtr sheet)
+{
+ // There are three types of output we need to be able to deal with:
+ // HTML (create an HTML document), XML (create an XML document),
+ // and text (wrap in a <pre> and create an XML document).
+
+ const xmlChar *resultType = 0;
+ XSLT_GET_IMPORT_PTR(resultType, sheet, method);
+ if (resultType == 0 && resultDoc->type == XML_HTML_DOCUMENT_NODE)
+ resultType = (const xmlChar *)"html";
+
+ if (xmlStrEqual(resultType, (const xmlChar *)"html"))
+ return DeprecatedString("text/html");
+ else if (xmlStrEqual(resultType, (const xmlChar *)"text"))
+ return DeprecatedString("text/plain");
+
+ return DeprecatedString("application/xml");
+}
+
+bool XSLTProcessor::transformToString(Node *sourceNode, DeprecatedString &mimeType, DeprecatedString &resultString, DeprecatedString &resultEncoding)
+{
+ RefPtr<Document> ownerDocument = sourceNode->document();
+
+ setXSLTLoadCallBack(docLoaderFunc, this, ownerDocument->docLoader());
+ xsltStylesheetPtr sheet = xsltStylesheetPointer(m_stylesheet, m_stylesheetRootNode.get());
+ if (!sheet) {
+ setXSLTLoadCallBack(0, 0, 0);
+ return false;
+ }
+ m_stylesheet->clearDocuments();
+
+ xmlChar* origMethod = sheet->method;
+ if (!origMethod && mimeType == "text/html")
+ sheet->method = (xmlChar*)"html";
+
+ bool success = false;
+ bool shouldFreeSourceDoc = false;
+ if (xmlDocPtr sourceDoc = xmlDocPtrFromNode(sourceNode, shouldFreeSourceDoc)) {
+ // The XML declaration would prevent parsing the result as a fragment, and it's not needed even for documents,
+ // as the result of this function is always immediately parsed.
+ sheet->omitXmlDeclaration = true;
+
+ xsltTransformContextPtr transformContext = xsltNewTransformContext(sheet, sourceDoc);
+ registerXSLTExtensions(transformContext);
+
+ // This is a workaround for a bug in libxslt.
+ // The bug has been fixed in version 1.1.13, so once we ship that this can be removed.
+ if (transformContext->globalVars == NULL)
+ transformContext->globalVars = xmlHashCreate(20);
+
+ const char **params = xsltParamArrayFromParameterMap(m_parameters);
+ xsltQuoteUserParams(transformContext, params);
+ xmlDocPtr resultDoc = xsltApplyStylesheetUser(sheet, sourceDoc, 0, 0, 0, transformContext);
+
+ xsltFreeTransformContext(transformContext);
+ freeXsltParamArray(params);
+
+ if (shouldFreeSourceDoc)
+ xmlFreeDoc(sourceDoc);
+
+ if (success = saveResultToString(resultDoc, sheet, resultString)) {
+ mimeType = resultMIMEType(resultDoc, sheet);
+ resultEncoding = (char *)resultDoc->encoding;
+ }
+ xmlFreeDoc(resultDoc);
+ }
+
+ sheet->method = origMethod;
+ setXSLTLoadCallBack(0, 0, 0);
+ xsltFreeStylesheet(sheet);
+ m_stylesheet = 0;
+
+ return success;
+}
+
+RefPtr<Document> XSLTProcessor::transformToDocument(Node *sourceNode)
+{
+ DeprecatedString resultMIMEType;
+ DeprecatedString resultString;
+ DeprecatedString resultEncoding;
+ if (!transformToString(sourceNode, resultMIMEType, resultString, resultEncoding))
+ return 0;
+ return createDocumentFromSource(resultString, resultEncoding, resultMIMEType, sourceNode, 0);
+}
+
+RefPtr<DocumentFragment> XSLTProcessor::transformToFragment(Node* sourceNode, Document* outputDoc)
+{
+ DeprecatedString resultMIMEType;
+ DeprecatedString resultString;
+ DeprecatedString resultEncoding;
+
+ // If the output document is HTML, default to HTML method.
+ if (outputDoc->isHTMLDocument())
+ resultMIMEType = "text/html";
+
+ if (!transformToString(sourceNode, resultMIMEType, resultString, resultEncoding))
+ return 0;
+ return createFragmentFromSource(resultString, resultMIMEType, sourceNode, outputDoc);
+}
+
+void XSLTProcessor::setParameter(const String& namespaceURI, const String& localName, const String& value)
+{
+ // FIXME: namespace support?
+ // should make a QualifiedName here but we'd have to expose the impl
+ m_parameters.set(localName, value);
+}
+
+String XSLTProcessor::getParameter(const String& namespaceURI, const String& localName) const
+{
+ // FIXME: namespace support?
+ // should make a QualifiedName here but we'd have to expose the impl
+ return m_parameters.get(localName);
+}
+
+void XSLTProcessor::removeParameter(const String& namespaceURI, const String& localName)
+{
+ // FIXME: namespace support?
+ m_parameters.remove(localName);
+}
+
+} // namespace WebCore
+
+#endif // ENABLE(XSLT)