d5f223cc2a3a9ea4f4728830db60d7a634e37d71
[WebKit-https.git] / WebCore / xml / XSLTProcessor.cpp
1 /**
2  * This file is part of the XSL implementation.
3  *
4  * Copyright (C) 2004, 2005, 2006, 2007 Apple, Inc.
5  * Copyright (C) 2005, 2006 Alexey Proskuryakov <ap@webkit.org>
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Library General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Library General Public License for more details.
16  *
17  * You should have received a copy of the GNU Library General Public License
18  * along with this library; see the file COPYING.LIB.  If not, write to
19  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20  * Boston, MA 02110-1301, USA.
21  */
22
23 #include "config.h"
24
25 #if ENABLE(XSLT)
26
27 #include "XSLTProcessor.h"
28
29 #include "CString.h"
30 #include "Cache.h"
31 #include "DOMImplementation.h"
32 #include "DocLoader.h"
33 #include "DocumentFragment.h"
34 #include "Frame.h"
35 #include "FrameLoader.h"
36 #include "FrameView.h"
37 #include "HTMLDocument.h"
38 #include "HTMLTokenizer.h"
39 #include "Page.h"
40 #include "ResourceHandle.h"
41 #include "ResourceRequest.h"
42 #include "ResourceResponse.h"
43 #include "Text.h"
44 #include "TextResourceDecoder.h"
45 #include "XMLTokenizer.h"
46 #include "XSLTExtensions.h"
47 #include "loader.h"
48 #include "markup.h"
49 #include <libxslt/imports.h>
50 #include <libxslt/variables.h>
51 #include <libxslt/xsltutils.h>
52 #include <wtf/Assertions.h>
53 #include <wtf/Platform.h>
54 #include <wtf/Vector.h>
55 #if PLATFORM(MAC)
56 #include "SoftLinking.h"
57 #endif
58
59 #if PLATFORM(MAC)
60 SOFT_LINK_LIBRARY(libxslt);
61 SOFT_LINK(libxslt, xsltFreeStylesheet, void, (xsltStylesheetPtr sheet), (sheet))
62 SOFT_LINK(libxslt, xsltFreeTransformContext, void, (xsltTransformContextPtr ctxt), (ctxt))
63 SOFT_LINK(libxslt, xsltNewTransformContext, xsltTransformContextPtr, (xsltStylesheetPtr style, xmlDocPtr doc), (style, doc))
64 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))
65 SOFT_LINK(libxslt, xsltQuoteUserParams, int, (xsltTransformContextPtr ctxt, const char** params), (ctxt, params))
66 SOFT_LINK(libxslt, xsltSetLoaderFunc, void, (xsltDocLoaderFunc f), (f))
67 SOFT_LINK(libxslt, xsltSaveResultTo, int, (xmlOutputBufferPtr buf, xmlDocPtr result, xsltStylesheetPtr style), (buf, result, style))
68 SOFT_LINK(libxslt, xsltNextImport, xsltStylesheetPtr, (xsltStylesheetPtr style), (style))
69 #endif
70
71 namespace WebCore {
72
73 void XSLTProcessor::parseErrorFunc(void* userData, xmlError* error)
74 {
75     Chrome* chrome = static_cast<Chrome*>(userData);
76     if (!chrome)
77         return;
78
79     MessageLevel level;
80     switch (error->level) {
81         case XML_ERR_NONE:
82             level = TipMessageLevel;
83             break;
84         case XML_ERR_WARNING:
85             level = WarningMessageLevel;
86             break;
87         case XML_ERR_ERROR:
88         case XML_ERR_FATAL:
89         default:
90             level = ErrorMessageLevel;
91             break;
92     }
93
94     chrome->addMessageToConsole(XMLMessageSource, level, error->message, error->line, error->file);
95 }
96
97 // FIXME: There seems to be no way to control the ctxt pointer for loading here, thus we have globals.
98 static XSLTProcessor* globalProcessor = 0;
99 static DocLoader* globalDocLoader = 0;
100 static xmlDocPtr docLoaderFunc(const xmlChar* uri,
101                                     xmlDictPtr dict,
102                                     int options,
103                                     void* ctxt,
104                                     xsltLoadType type)
105 {
106     if (!globalProcessor)
107         return 0;
108     
109     switch (type) {
110         case XSLT_LOAD_DOCUMENT: {
111             xsltTransformContextPtr context = (xsltTransformContextPtr)ctxt;
112             xmlChar* base = xmlNodeGetBase(context->document->doc, context->node);
113             KURL url((const char*)base, (const char*)uri);
114             xmlFree(base);
115             ResourceError error;
116             ResourceResponse response;
117
118             Vector<char> data;
119
120             if (globalDocLoader->frame()) 
121                 globalDocLoader->frame()->loader()->loadResourceSynchronously(url, error, response, data);
122
123             Chrome* chrome = 0;
124             if (Page* page = globalProcessor->xslStylesheet()->ownerDocument()->page())
125                 chrome = page->chrome();
126             xmlSetStructuredErrorFunc(chrome, XSLTProcessor::parseErrorFunc);
127
128             // We don't specify an encoding here. Neither Gecko nor WinIE respects
129             // the encoding specified in the HTTP headers.
130             xmlDocPtr doc = xmlReadMemory(data.data(), data.size(), (const char*)uri, 0, options);
131
132             xmlSetStructuredErrorFunc(0, 0);
133
134             return doc;
135         }
136         case XSLT_LOAD_STYLESHEET:
137             return globalProcessor->xslStylesheet()->locateStylesheetSubResource(((xsltStylesheetPtr)ctxt)->doc, uri);
138         default:
139             break;
140     }
141     
142     return 0;
143 }
144
145 static inline void setXSLTLoadCallBack(xsltDocLoaderFunc func, XSLTProcessor* processor, DocLoader* loader)
146 {
147     xsltSetLoaderFunc(func);
148     globalProcessor = processor;
149     globalDocLoader = loader;
150 }
151
152 static int writeToString(void* context, const char* buffer, int len)
153 {
154     String& resultOutput = *static_cast<String*>(context);
155     resultOutput += String::fromUTF8(buffer, len);
156     return len;
157 }
158
159 static bool saveResultToString(xmlDocPtr resultDoc, xsltStylesheetPtr sheet, String& resultString)
160 {
161     xmlOutputBufferPtr outputBuf = xmlAllocOutputBuffer(0);
162     if (!outputBuf)
163         return false;
164     outputBuf->context = &resultString;
165     outputBuf->writecallback = writeToString;
166     
167     int retval = xsltSaveResultTo(outputBuf, resultDoc, sheet);
168     xmlOutputBufferClose(outputBuf);
169     
170     return (retval >= 0);
171 }
172
173 static inline void transformTextStringToXHTMLDocumentString(String& text)
174 {
175     // Modify the output so that it is a well-formed XHTML document with a <pre> tag enclosing the text.
176     text.replace('&', "&amp;");
177     text.replace('<', "&lt;");
178     text = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
179         "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n"
180         "<html xmlns=\"http://www.w3.org/1999/xhtml\">\n"
181         "<head><title/></head>\n"
182         "<body>\n"
183         "<pre>" + text + "</pre>\n"
184         "</body>\n"
185         "</html>\n";
186 }
187
188 static const char** xsltParamArrayFromParameterMap(XSLTProcessor::ParameterMap& parameters)
189 {
190     if (parameters.isEmpty())
191         return 0;
192
193     const char** parameterArray = (const char**)fastMalloc(((parameters.size() * 2) + 1) * sizeof(char*));
194
195     XSLTProcessor::ParameterMap::iterator end = parameters.end();
196     unsigned index = 0;
197     for (XSLTProcessor::ParameterMap::iterator it = parameters.begin(); it != end; ++it) {
198         parameterArray[index++] = strdup(it->first.utf8().data());
199         parameterArray[index++] = strdup(it->second.utf8().data());
200     }
201     parameterArray[index] = 0;
202
203     return parameterArray;
204 }
205
206 static void freeXsltParamArray(const char** params)
207 {
208     const char** temp = params;
209     if (!params)
210         return;
211     
212     while (*temp) {
213         free((void*)*(temp++)); // strdup returns malloc'd blocks, so we have to use free() here
214         free((void*)*(temp++));
215     }
216     fastFree(params);
217 }
218
219
220 RefPtr<Document> XSLTProcessor::createDocumentFromSource(const String& sourceString,
221     const String& sourceEncoding, const String& sourceMIMEType, Node* sourceNode, Frame* frame)
222 {
223     RefPtr<Document> ownerDocument = sourceNode->document();
224     bool sourceIsDocument = (sourceNode == ownerDocument.get());
225     String documentSource = sourceString;
226
227     RefPtr<Document> result;
228     if (sourceMIMEType == "text/plain") {
229         result = ownerDocument->implementation()->createDocument(frame);
230         transformTextStringToXHTMLDocumentString(documentSource);
231     } else
232         result = ownerDocument->implementation()->createDocument(sourceMIMEType, frame, false);
233     
234     // Before parsing, we need to save & detach the old document and get the new document
235     // in place. We have to do this only if we're rendering the result document.
236     if (frame) {
237         if (FrameView* view = frame->view())
238             view->clear();
239         result->setTransformSourceDocument(frame->document());
240         frame->setDocument(result);
241     }
242     
243     result->open();
244     if (sourceIsDocument) {
245         result->setURL(ownerDocument->URL());
246         result->setBaseURL(ownerDocument->baseURL());
247     }
248     result->determineParseMode(documentSource); // Make sure we parse in the correct mode.
249     
250     RefPtr<TextResourceDecoder> decoder = new TextResourceDecoder(sourceMIMEType);
251     decoder->setEncoding(sourceEncoding.isEmpty() ? UTF8Encoding() : TextEncoding(sourceEncoding), TextResourceDecoder::EncodingFromXMLHeader);
252     result->setDecoder(decoder.get());
253     
254     result->write(documentSource);
255     result->finishParsing();
256     result->close();
257
258     return result;
259 }
260
261 static inline RefPtr<DocumentFragment> createFragmentFromSource(String sourceString, String sourceMIMEType, Node* sourceNode, Document* outputDoc)
262 {
263     RefPtr<DocumentFragment> fragment = new DocumentFragment(outputDoc);
264     
265     if (sourceMIMEType == "text/html")
266         parseHTMLDocumentFragment(sourceString, fragment.get());
267     else if (sourceMIMEType == "text/plain")
268         fragment->addChild(new Text(outputDoc, sourceString));
269     else {
270         bool successfulParse = parseXMLDocumentFragment(sourceString, fragment.get(), outputDoc->documentElement());
271         if (!successfulParse)
272             return 0;
273     }
274     
275     // FIXME: Do we need to mess with URLs here?
276         
277     return fragment;
278 }
279
280 static xsltStylesheetPtr xsltStylesheetPointer(RefPtr<XSLStyleSheet>& cachedStylesheet, Node* stylesheetRootNode)
281 {
282     if (!cachedStylesheet && stylesheetRootNode) {
283         cachedStylesheet = new XSLStyleSheet(stylesheetRootNode->parent() ? stylesheetRootNode->parent() : stylesheetRootNode, stylesheetRootNode->document()->URL());
284         cachedStylesheet->parseString(createMarkup(stylesheetRootNode));
285     }
286     
287     if (!cachedStylesheet || !cachedStylesheet->document())
288         return 0;
289     
290     return cachedStylesheet->compileStyleSheet();
291 }
292
293 static inline xmlDocPtr xmlDocPtrFromNode(Node* sourceNode, bool& shouldDelete)
294 {
295     RefPtr<Document> ownerDocument = sourceNode->document();
296     bool sourceIsDocument = (sourceNode == ownerDocument.get());
297     
298     xmlDocPtr sourceDoc = 0;
299     if (sourceIsDocument)
300         sourceDoc = (xmlDocPtr)ownerDocument->transformSource();
301     if (!sourceDoc) {
302         sourceDoc = (xmlDocPtr)xmlDocPtrForString(ownerDocument->docLoader(), createMarkup(sourceNode), sourceIsDocument ? ownerDocument->URL() : DeprecatedString());
303         shouldDelete = (sourceDoc != 0);
304     }
305     return sourceDoc;
306 }
307
308 static inline String resultMIMEType(xmlDocPtr resultDoc, xsltStylesheetPtr sheet)
309 {
310     // There are three types of output we need to be able to deal with:
311     // HTML (create an HTML document), XML (create an XML document),
312     // and text (wrap in a <pre> and create an XML document).
313
314     const xmlChar* resultType = 0;
315     XSLT_GET_IMPORT_PTR(resultType, sheet, method);
316     if (resultType == 0 && resultDoc->type == XML_HTML_DOCUMENT_NODE)
317         resultType = (const xmlChar*)"html";
318     
319     if (xmlStrEqual(resultType, (const xmlChar*)"html"))
320         return "text/html";
321     else if (xmlStrEqual(resultType, (const xmlChar*)"text"))
322         return "text/plain";
323         
324     return "application/xml";
325 }
326
327 bool XSLTProcessor::transformToString(Node* sourceNode, String& mimeType, String& resultString, String& resultEncoding)
328 {
329     RefPtr<Document> ownerDocument = sourceNode->document();
330     
331     setXSLTLoadCallBack(docLoaderFunc, this, ownerDocument->docLoader());
332     xsltStylesheetPtr sheet = xsltStylesheetPointer(m_stylesheet, m_stylesheetRootNode.get());
333     if (!sheet) {
334         setXSLTLoadCallBack(0, 0, 0);
335         return false;
336     }
337     m_stylesheet->clearDocuments();
338
339     xmlChar* origMethod = sheet->method;
340     if (!origMethod && mimeType == "text/html")
341         sheet->method = (xmlChar*)"html";
342
343     bool success = false;
344     bool shouldFreeSourceDoc = false;
345     if (xmlDocPtr sourceDoc = xmlDocPtrFromNode(sourceNode, shouldFreeSourceDoc)) {
346         // The XML declaration would prevent parsing the result as a fragment, and it's not needed even for documents, 
347         // as the result of this function is always immediately parsed.
348         sheet->omitXmlDeclaration = true;
349
350         xsltTransformContextPtr transformContext = xsltNewTransformContext(sheet, sourceDoc);
351         registerXSLTExtensions(transformContext);
352
353         // This is a workaround for a bug in libxslt. 
354         // The bug has been fixed in version 1.1.13, so once we ship that this can be removed.
355         if (transformContext->globalVars == NULL)
356            transformContext->globalVars = xmlHashCreate(20);
357
358         const char** params = xsltParamArrayFromParameterMap(m_parameters);
359         xsltQuoteUserParams(transformContext, params);
360         xmlDocPtr resultDoc = xsltApplyStylesheetUser(sheet, sourceDoc, 0, 0, 0, transformContext);
361         
362         xsltFreeTransformContext(transformContext);        
363         freeXsltParamArray(params);
364         
365         if (shouldFreeSourceDoc)
366             xmlFreeDoc(sourceDoc);
367         
368         if (success = saveResultToString(resultDoc, sheet, resultString)) {
369             mimeType = resultMIMEType(resultDoc, sheet);
370             resultEncoding = (char*)resultDoc->encoding;
371         }
372         xmlFreeDoc(resultDoc);
373     }
374     
375     sheet->method = origMethod;
376     setXSLTLoadCallBack(0, 0, 0);
377     xsltFreeStylesheet(sheet);
378     m_stylesheet = 0;
379
380     return success;
381 }
382
383 RefPtr<Document> XSLTProcessor::transformToDocument(Node* sourceNode)
384 {
385     String resultMIMEType;
386     String resultString;
387     String resultEncoding;
388     if (!transformToString(sourceNode, resultMIMEType, resultString, resultEncoding))
389         return 0;
390     return createDocumentFromSource(resultString, resultEncoding, resultMIMEType, sourceNode, 0);
391 }
392
393 RefPtr<DocumentFragment> XSLTProcessor::transformToFragment(Node* sourceNode, Document* outputDoc)
394 {
395     String resultMIMEType;
396     String resultString;
397     String resultEncoding;
398
399     // If the output document is HTML, default to HTML method.
400     if (outputDoc->isHTMLDocument())
401         resultMIMEType = "text/html";
402     
403     if (!transformToString(sourceNode, resultMIMEType, resultString, resultEncoding))
404         return 0;
405     return createFragmentFromSource(resultString, resultMIMEType, sourceNode, outputDoc);
406 }
407
408 void XSLTProcessor::setParameter(const String& namespaceURI, const String& localName, const String& value)
409 {
410     // FIXME: namespace support?
411     // should make a QualifiedName here but we'd have to expose the impl
412     m_parameters.set(localName, value);
413 }
414
415 String XSLTProcessor::getParameter(const String& namespaceURI, const String& localName) const
416 {
417     // FIXME: namespace support?
418     // should make a QualifiedName here but we'd have to expose the impl
419     return m_parameters.get(localName);
420 }
421
422 void XSLTProcessor::removeParameter(const String& namespaceURI, const String& localName)
423 {
424     // FIXME: namespace support?
425     m_parameters.remove(localName);
426 }
427
428 } // namespace WebCore
429
430 #endif // ENABLE(XSLT)